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$"
40 from novaclient
import client
as nClient
, exceptions
as nvExceptions
41 from keystoneauth1
.identity
import v2
, v3
42 from keystoneauth1
import session
43 import keystoneclient
.exceptions
as ksExceptions
44 import keystoneclient
.v3
.client
as ksClient_v3
45 import keystoneclient
.v2_0
.client
as ksClient_v2
46 from glanceclient
import client
as glClient
47 import glanceclient
.client
as gl1Client
48 import glanceclient
.exc
as gl1Exceptions
49 from cinderclient
import client
as cClient
50 from httplib
import HTTPException
51 from neutronclient
.neutron
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 api_version
= config
.get('APIversion')
78 if api_version
and api_version
not in ('v3.3', 'v2.0', '2', '3'):
79 raise vimconn
.vimconnException("Invalid value '{}' for config:APIversion. "
80 "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version
))
81 vim_type
= config
.get('vim_type')
82 if vim_type
and vim_type
not in ('vio', 'VIO'):
83 raise vimconn
.vimconnException("Invalid value '{}' for config:vim_type."
84 "Allowed values are 'vio' or 'VIO'".format(vim_type
))
86 if config
.get('dataplane_net_vlan_range') is not None:
87 #validate vlan ranges provided by user
88 self
._validate
_vlan
_ranges
(config
.get('dataplane_net_vlan_range'))
90 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
,
93 self
.insecure
= self
.config
.get("insecure", False)
95 raise TypeError, 'url param can not be NoneType'
96 self
.persistent_info
= persistent_info
97 self
.session
= persistent_info
.get('session', {'reload_client': True})
98 self
.nova
= self
.session
.get('nova')
99 self
.neutron
= self
.session
.get('neutron')
100 self
.cinder
= self
.session
.get('cinder')
101 self
.glance
= self
.session
.get('glance')
102 self
.glancev1
= self
.session
.get('glancev1')
103 self
.keystone
= self
.session
.get('keystone')
104 self
.api_version3
= self
.session
.get('api_version3')
105 self
.vim_type
= self
.config
.get("vim_type")
107 self
.vim_type
= self
.vim_type
.upper()
108 if self
.config
.get("use_internal_endpoint"):
109 self
.endpoint_type
= "internalURL"
111 self
.endpoint_type
= None
113 self
.logger
= logging
.getLogger('openmano.vim.openstack')
115 ####### VIO Specific Changes #########
116 if self
.vim_type
== "VIO":
117 self
.logger
= logging
.getLogger('openmano.vim.vio')
120 self
.logger
.setLevel(getattr(logging
, log_level
))
122 def __getitem__(self
, index
):
123 """Get individuals parameters.
125 if index
== 'project_domain_id':
126 return self
.config
.get("project_domain_id")
127 elif index
== 'user_domain_id':
128 return self
.config
.get("user_domain_id")
130 return vimconn
.vimconnector
.__getitem
__(self
, index
)
132 def __setitem__(self
, index
, value
):
133 """Set individuals parameters and it is marked as dirty so to force connection reload.
135 if index
== 'project_domain_id':
136 self
.config
["project_domain_id"] = value
137 elif index
== 'user_domain_id':
138 self
.config
["user_domain_id"] = value
140 vimconn
.vimconnector
.__setitem
__(self
, index
, value
)
141 self
.session
['reload_client'] = True
143 def _reload_connection(self
):
144 '''Called before any operation, it check if credentials has changed
145 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
147 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
148 if self
.session
['reload_client']:
149 if self
.config
.get('APIversion'):
150 self
.api_version3
= self
.config
['APIversion'] == 'v3.3' or self
.config
['APIversion'] == '3'
151 else: # get from ending auth_url that end with v3 or with v2.0
152 self
.api_version3
= self
.url
.split("/")[-1] == "v3"
153 self
.session
['api_version3'] = self
.api_version3
154 if self
.api_version3
:
155 auth
= v3
.Password(auth_url
=self
.url
,
157 password
=self
.passwd
,
158 project_name
=self
.tenant_name
,
159 project_id
=self
.tenant_id
,
160 project_domain_id
=self
.config
.get('project_domain_id', 'default'),
161 user_domain_id
=self
.config
.get('user_domain_id', 'default'))
163 auth
= v2
.Password(auth_url
=self
.url
,
165 password
=self
.passwd
,
166 tenant_name
=self
.tenant_name
,
167 tenant_id
=self
.tenant_id
)
168 sess
= session
.Session(auth
=auth
, verify
=not self
.insecure
)
169 if self
.api_version3
:
170 self
.keystone
= ksClient_v3
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
172 self
.keystone
= ksClient_v2
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
173 self
.session
['keystone'] = self
.keystone
174 self
.nova
= self
.session
['nova'] = nClient
.Client("2.1", session
=sess
, endpoint_type
=self
.endpoint_type
)
175 self
.neutron
= self
.session
['neutron'] = neClient
.Client('2.0', session
=sess
, endpoint_type
=self
.endpoint_type
)
176 self
.cinder
= self
.session
['cinder'] = cClient
.Client(2, session
=sess
, endpoint_type
=self
.endpoint_type
)
177 if self
.endpoint_type
== "internalURL":
178 glance_service_id
= self
.keystone
.services
.list(name
="glance")[0].id
179 glance_endpoint
= self
.keystone
.endpoints
.list(glance_service_id
, interface
="internal")[0].url
181 glance_endpoint
= None
182 self
.glance
= self
.session
['glance'] = glClient
.Client(2, session
=sess
, endpoint
=glance_endpoint
)
183 #using version 1 of glance client in new_image()
184 self
.glancev1
= self
.session
['glancev1'] = glClient
.Client('1', session
=sess
,
185 endpoint
=glance_endpoint
)
186 self
.session
['reload_client'] = False
187 self
.persistent_info
['session'] = self
.session
189 def __net_os2mano(self
, net_list_dict
):
190 '''Transform the net openstack format to mano format
191 net_list_dict can be a list of dict or a single dict'''
192 if type(net_list_dict
) is dict:
193 net_list_
=(net_list_dict
,)
194 elif type(net_list_dict
) is list:
195 net_list_
=net_list_dict
197 raise TypeError("param net_list_dict must be a list or a dictionary")
198 for net
in net_list_
:
199 if net
.get('provider:network_type') == "vlan":
204 def _format_exception(self
, exception
):
205 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
206 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
207 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
209 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
210 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
211 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
212 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
213 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
214 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
215 elif isinstance(exception
, nvExceptions
.Conflict
):
216 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
218 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
220 def get_tenant_list(self
, filter_dict
={}):
221 '''Obtain tenants of VIM
222 filter_dict can contain the following keys:
223 name: filter by tenant name
224 id: filter by tenant uuid/id
226 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
228 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
230 self
._reload
_connection
()
231 if self
.api_version3
:
232 project_class_list
= self
.keystone
.projects
.list(name
=filter_dict
.get("name"))
234 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
236 for project
in project_class_list
:
237 if filter_dict
.get('id') and filter_dict
["id"] != project
.id:
239 project_list
.append(project
.to_dict())
241 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
242 self
._format
_exception
(e
)
244 def new_tenant(self
, tenant_name
, tenant_description
):
245 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
246 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
248 self
._reload
_connection
()
249 if self
.api_version3
:
250 project
= self
.keystone
.projects
.create(tenant_name
, self
.config
.get("project_domain_id", "default"),
251 description
=tenant_description
, is_domain
=False)
253 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
255 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
256 self
._format
_exception
(e
)
258 def delete_tenant(self
, tenant_id
):
259 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
260 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
262 self
._reload
_connection
()
263 if self
.api_version3
:
264 self
.keystone
.projects
.delete(tenant_id
)
266 self
.keystone
.tenants
.delete(tenant_id
)
268 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
269 self
._format
_exception
(e
)
271 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
272 '''Adds a tenant network to VIM. Returns the network identifier'''
273 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
274 #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
277 self
._reload
_connection
()
278 network_dict
= {'name': net_name
, 'admin_state_up': True}
279 if net_type
=="data" or net_type
=="ptp":
280 if self
.config
.get('dataplane_physical_net') == None:
281 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
282 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
283 network_dict
["provider:network_type"] = "vlan"
285 network_dict
["provider:network_type"] = vlan
287 ####### VIO Specific Changes #########
288 if self
.vim_type
== "VIO":
290 network_dict
["provider:segmentation_id"] = vlan
292 if self
.config
.get('dataplane_net_vlan_range') is None:
293 raise vimconn
.vimconnConflictException("You must provide "\
294 "'dataplane_net_vlan_range' in format [start_ID - end_ID]"\
295 "at config value before creating sriov network with vlan tag")
297 network_dict
["provider:segmentation_id"] = self
._genrate
_vlanID
()
299 network_dict
["shared"]=shared
300 new_net
=self
.neutron
.create_network({'network':network_dict
})
302 #create subnetwork, even if there is no profile
305 if 'subnet_address' not in ip_profile
:
306 #Fake subnet is required
307 subnet_rand
= random
.randint(0, 255)
308 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
309 if 'ip_version' not in ip_profile
:
310 ip_profile
['ip_version'] = "IPv4"
311 subnet
={"name":net_name
+"-subnet",
312 "network_id": new_net
["network"]["id"],
313 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
314 "cidr": ip_profile
['subnet_address']
316 if 'gateway_address' in ip_profile
:
317 subnet
['gateway_ip'] = ip_profile
['gateway_address']
318 if ip_profile
.get('dns_address'):
319 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
320 if 'dhcp_enabled' in ip_profile
:
321 subnet
['enable_dhcp'] = False if ip_profile
['dhcp_enabled']=="false" else True
322 if 'dhcp_start_address' in ip_profile
:
323 subnet
['allocation_pools']=[]
324 subnet
['allocation_pools'].append(dict())
325 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
326 if 'dhcp_count' in ip_profile
:
327 #parts = ip_profile['dhcp_start_address'].split('.')
328 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
329 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
330 ip_int
+= ip_profile
['dhcp_count'] - 1
331 ip_str
= str(netaddr
.IPAddress(ip_int
))
332 subnet
['allocation_pools'][0]['end'] = ip_str
333 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
334 self
.neutron
.create_subnet({"subnet": subnet
} )
335 return new_net
["network"]["id"]
336 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
338 self
.neutron
.delete_network(new_net
['network']['id'])
339 self
._format
_exception
(e
)
341 def get_network_list(self
, filter_dict
={}):
342 '''Obtain tenant networks of VIM
348 admin_state_up: boolean
350 Returns the network list of dictionaries
352 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
354 self
._reload
_connection
()
355 if self
.api_version3
and "tenant_id" in filter_dict
:
356 filter_dict
['project_id'] = filter_dict
.pop('tenant_id') #TODO check
357 net_dict
=self
.neutron
.list_networks(**filter_dict
)
358 net_list
=net_dict
["networks"]
359 self
.__net
_os
2mano
(net_list
)
361 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
362 self
._format
_exception
(e
)
364 def get_network(self
, net_id
):
365 '''Obtain details of network from VIM
366 Returns the network information from a network id'''
367 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
368 filter_dict
={"id": net_id
}
369 net_list
= self
.get_network_list(filter_dict
)
371 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
372 elif len(net_list
)>1:
373 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
376 for subnet_id
in net
.get("subnets", () ):
378 subnet
= self
.neutron
.show_subnet(subnet_id
)
379 except Exception as e
:
380 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
381 subnet
= {"id": subnet_id
, "fault": str(e
)}
382 subnets
.append(subnet
)
383 net
["subnets"] = subnets
384 net
["encapsulation"] = net
.get('provider:network_type')
385 net
["segmentation_id"] = net
.get('provider:segmentation_id')
388 def delete_network(self
, net_id
):
389 '''Deletes a tenant network from VIM. Returns the old network identifier'''
390 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
392 self
._reload
_connection
()
393 #delete VM ports attached to this networks before the network
394 ports
= self
.neutron
.list_ports(network_id
=net_id
)
395 for p
in ports
['ports']:
397 self
.neutron
.delete_port(p
["id"])
398 except Exception as e
:
399 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
400 self
.neutron
.delete_network(net_id
)
402 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
403 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
404 self
._format
_exception
(e
)
406 def refresh_nets_status(self
, net_list
):
407 '''Get the status of the networks
408 Params: the list of network identifiers
409 Returns a dictionary with:
410 net_id: #VIM id of this network
411 status: #Mandatory. Text with one of:
412 # DELETED (not found at vim)
413 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
414 # OTHER (Vim reported other status not understood)
415 # ERROR (VIM indicates an ERROR status)
416 # ACTIVE, INACTIVE, DOWN (admin down),
417 # BUILD (on building process)
419 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
420 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
424 for net_id
in net_list
:
427 net_vim
= self
.get_network(net_id
)
428 if net_vim
['status'] in netStatus2manoFormat
:
429 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
431 net
["status"] = "OTHER"
432 net
["error_msg"] = "VIM status reported " + net_vim
['status']
434 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
435 net
['status'] = 'DOWN'
437 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
438 except yaml
.representer
.RepresenterError
:
439 net
['vim_info'] = str(net_vim
)
440 if net_vim
.get('fault'): #TODO
441 net
['error_msg'] = str(net_vim
['fault'])
442 except vimconn
.vimconnNotFoundException
as e
:
443 self
.logger
.error("Exception getting net status: %s", str(e
))
444 net
['status'] = "DELETED"
445 net
['error_msg'] = str(e
)
446 except vimconn
.vimconnException
as e
:
447 self
.logger
.error("Exception getting net status: %s", str(e
))
448 net
['status'] = "VIM_ERROR"
449 net
['error_msg'] = str(e
)
450 net_dict
[net_id
] = net
453 def get_flavor(self
, flavor_id
):
454 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
455 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
457 self
._reload
_connection
()
458 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
459 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
460 return flavor
.to_dict()
461 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
462 self
._format
_exception
(e
)
464 def get_flavor_id_from_data(self
, flavor_dict
):
465 """Obtain flavor id that match the flavor description
466 Returns the flavor_id or raises a vimconnNotFoundException
467 flavor_dict: contains the required ram, vcpus, disk
468 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
469 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
470 vimconnNotFoundException is raised
472 exact_match
= False if self
.config
.get('use_existing_flavors') else True
474 self
._reload
_connection
()
475 flavor_candidate_id
= None
476 flavor_candidate_data
= (10000, 10000, 10000)
477 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
479 numas
= flavor_dict
.get("extended", {}).get("numas")
482 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemted")
484 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
486 # numas = extended.get("numas")
487 for flavor
in self
.nova
.flavors
.list():
488 epa
= flavor
.get_keys()
492 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
493 if flavor_data
== flavor_target
:
495 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
496 flavor_candidate_id
= flavor
.id
497 flavor_candidate_data
= flavor_data
498 if not exact_match
and flavor_candidate_id
:
499 return flavor_candidate_id
500 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
501 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
502 self
._format
_exception
(e
)
505 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
506 '''Adds a tenant flavor to openstack VIM
507 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
508 Returns the flavor identifier
510 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
514 name
=flavor_data
['name']
515 while retry
<max_retries
:
518 self
._reload
_connection
()
519 if change_name_if_used
:
522 fl
=self
.nova
.flavors
.list()
524 fl_names
.append(f
.name
)
525 while name
in fl_names
:
527 name
= flavor_data
['name']+"-" + str(name_suffix
)
529 ram
= flavor_data
.get('ram',64)
530 vcpus
= flavor_data
.get('vcpus',1)
533 extended
= flavor_data
.get("extended")
535 numas
=extended
.get("numas")
537 numa_nodes
= len(numas
)
539 return -1, "Can not add flavor with more than one numa"
540 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
541 numa_properties
["hw:mem_page_size"] = "large"
542 numa_properties
["hw:cpu_policy"] = "dedicated"
543 numa_properties
["hw:numa_mempolicy"] = "strict"
544 if self
.vim_type
== "VIO":
545 numa_properties
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
546 numa_properties
["vmware:latency_sensitivity_level"] = "high"
548 #overwrite ram and vcpus
549 ram
= numa
['memory']*1024
550 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
551 if 'paired-threads' in numa
:
552 vcpus
= numa
['paired-threads']*2
553 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
554 numa_properties
["hw:cpu_thread_policy"] = "require"
555 numa_properties
["hw:cpu_policy"] = "dedicated"
556 elif 'cores' in numa
:
557 vcpus
= numa
['cores']
558 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
559 numa_properties
["hw:cpu_thread_policy"] = "isolate"
560 numa_properties
["hw:cpu_policy"] = "dedicated"
561 elif 'threads' in numa
:
562 vcpus
= numa
['threads']
563 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
564 numa_properties
["hw:cpu_thread_policy"] = "prefer"
565 numa_properties
["hw:cpu_policy"] = "dedicated"
566 # for interface in numa.get("interfaces",() ):
567 # if interface["dedicated"]=="yes":
568 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
569 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
572 new_flavor
=self
.nova
.flavors
.create(name
,
575 flavor_data
.get('disk',1),
576 is_public
=flavor_data
.get('is_public', True)
580 new_flavor
.set_keys(numa_properties
)
582 except nvExceptions
.Conflict
as e
:
583 if change_name_if_used
and retry
< max_retries
:
585 self
._format
_exception
(e
)
586 #except nvExceptions.BadRequest as e:
587 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
588 self
._format
_exception
(e
)
590 def delete_flavor(self
,flavor_id
):
591 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
594 self
._reload
_connection
()
595 self
.nova
.flavors
.delete(flavor_id
)
597 #except nvExceptions.BadRequest as e:
598 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
599 self
._format
_exception
(e
)
601 def new_image(self
,image_dict
):
603 Adds a tenant image to VIM. imge_dict is a dictionary with:
605 disk_format: qcow2, vhd, vmdk, raw (by default), ...
606 location: path or URI
607 public: "yes" or "no"
608 metadata: metadata of the image
611 # ALF TODO: revise and change for the new method or session
614 while retry
<max_retries
:
617 self
._reload
_connection
()
618 #determine format http://docs.openstack.org/developer/glance/formats.html
619 if "disk_format" in image_dict
:
620 disk_format
=image_dict
["disk_format"]
621 else: #autodiscover based on extension
622 if image_dict
['location'][-6:]==".qcow2":
624 elif image_dict
['location'][-4:]==".vhd":
626 elif image_dict
['location'][-5:]==".vmdk":
628 elif image_dict
['location'][-4:]==".vdi":
630 elif image_dict
['location'][-4:]==".iso":
632 elif image_dict
['location'][-4:]==".aki":
634 elif image_dict
['location'][-4:]==".ari":
636 elif image_dict
['location'][-4:]==".ami":
640 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
641 if image_dict
['location'][0:4]=="http":
642 new_image
= self
.glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
643 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
645 with
open(image_dict
['location']) as fimage
:
646 new_image
= self
.glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
647 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
648 #insert metadata. We cannot use 'new_image.properties.setdefault'
649 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
650 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
651 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
652 metadata_to_load
= image_dict
.get('metadata')
654 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
655 new_image_nova
.metadata
.setdefault(k
,v
)
657 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
658 self
._format
_exception
(e
)
659 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
660 if retry
==max_retries
:
662 self
._format
_exception
(e
)
663 except IOError as e
: #can not open the file
664 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
665 http_code
=vimconn
.HTTP_Bad_Request
)
667 def delete_image(self
, image_id
):
668 '''Deletes a tenant image from openstack VIM. Returns the old id
671 self
._reload
_connection
()
672 self
.nova
.images
.delete(image_id
)
674 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
675 self
._format
_exception
(e
)
677 def get_image_id_from_path(self
, path
):
678 '''Get the image id from image path in the VIM database. Returns the image_id'''
680 self
._reload
_connection
()
681 images
= self
.nova
.images
.list()
683 if image
.metadata
.get("location")==path
:
685 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
686 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
687 self
._format
_exception
(e
)
689 def get_image_list(self
, filter_dict
={}):
690 '''Obtain tenant images from VIM
694 checksum: image checksum
695 Returns the image list of dictionaries:
696 [{<the fields at Filter_dict plus some VIM specific>}, ...]
699 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
701 self
._reload
_connection
()
702 filter_dict_os
=filter_dict
.copy()
703 #First we filter by the available filter fields: name, id. The others are removed.
704 filter_dict_os
.pop('checksum',None)
705 image_list
=self
.nova
.images
.findall(**filter_dict_os
)
706 if len(image_list
)==0:
708 #Then we filter by the rest of filter fields: checksum
710 for image
in image_list
:
711 image_class
=self
.glance
.images
.get(image
.id)
712 if 'checksum' not in filter_dict
or image_class
['checksum']==filter_dict
.get('checksum'):
713 filtered_list
.append(image_class
.copy())
715 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
716 self
._format
_exception
(e
)
719 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None,disk_list
=None):
720 '''Adds a VM instance to VIM
722 start: indicates if VM must start or boot in pause mode. Ignored
723 image_id,flavor_id: iamge and flavor uuid
724 net_list: list of interfaces, each one is a dictionary with:
726 net_id: network uuid to connect
727 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
728 model: interface model, ignored #TODO
729 mac_address: used for SR-IOV ifaces #TODO for other types
730 use: 'data', 'bridge', 'mgmt'
731 type: 'virtual', 'PF', 'VF', 'VFnotShared'
732 vim_id: filled/added by this function
733 floating_ip: True/False (or it can be None)
734 #TODO ip, security groups
735 Returns the instance identifier
737 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
741 external_network
=[] #list of external networks to be connected to instance, later on used to create floating_ip
742 self
._reload
_connection
()
743 metadata_vpci
= {} #For a specific neutron plugin
745 if not net
.get("net_id"): #skip non connected iface
749 "network_id": net
["net_id"],
750 "name": net
.get("name"),
751 "admin_state_up": True
753 if net
["type"]=="virtual":
755 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
756 elif net
["type"]=="VF": # for VF
758 if "VF" not in metadata_vpci
:
759 metadata_vpci
["VF"]=[]
760 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
761 port_dict
["binding:vnic_type"]="direct"
762 ########## VIO specific Changes #######
763 if self
.vim_type
== "VIO":
764 #Need to create port with port_security_enabled = False and no-security-groups
765 port_dict
["port_security_enabled"]=False
766 port_dict
["provider_security_groups"]=[]
767 port_dict
["security_groups"]=[]
769 ########## VIO specific Changes #######
770 #Current VIO release does not support port with type 'direct-physical'
771 #So no need to create virtual port in case of PCI-device.
772 #Will update port_dict code when support gets added in next VIO release
773 if self
.vim_type
== "VIO":
774 raise vimconn
.vimconnNotSupportedException("Current VIO release does not support full passthrough (PT)")
776 if "PF" not in metadata_vpci
:
777 metadata_vpci
["PF"]=[]
778 metadata_vpci
["PF"].append([ net
["vpci"], "" ])
779 port_dict
["binding:vnic_type"]="direct-physical"
780 if not port_dict
["name"]:
781 port_dict
["name"]=name
782 if net
.get("mac_address"):
783 port_dict
["mac_address"]=net
["mac_address"]
784 if net
.get("port_security") == False:
785 port_dict
["port_security_enabled"]=net
["port_security"]
787 new_port
= self
.neutron
.create_port({"port": port_dict
})
789 net
["mac_adress"] = new_port
["port"]["mac_address"]
790 net
["vim_id"] = new_port
["port"]["id"]
791 net
["ip"] = new_port
["port"].get("fixed_ips", [{}])[0].get("ip_address")
792 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
794 if net
.get('floating_ip', False):
795 net
['exit_on_floating_ip_error'] = True
796 external_network
.append(net
)
797 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
798 net
['exit_on_floating_ip_error'] = False
799 external_network
.append(net
)
802 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
803 if len(metadata
["pci_assignement"]) >255:
804 #limit the metadata size
805 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
806 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
809 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
810 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
812 security_groups
= self
.config
.get('security_groups')
813 if type(security_groups
) is str:
814 security_groups
= ( security_groups
, )
818 if isinstance(cloud_config
, dict):
819 if cloud_config
.get("user-data"):
820 userdata
=cloud_config
["user-data"]
821 if cloud_config
.get("boot-data-drive") != None:
822 config_drive
= cloud_config
["boot-data-drive"]
823 if cloud_config
.get("config-files") or cloud_config
.get("users") or cloud_config
.get("key-pairs"):
825 raise vimconn
.vimconnConflictException("Cloud-config cannot contain both 'userdata' and 'config-files'/'users'/'key-pairs'")
828 if cloud_config
.get("key-pairs"):
829 userdata_dict
["ssh-authorized-keys"] = cloud_config
["key-pairs"]
830 userdata_dict
["users"] = [{"default": None, "ssh-authorized-keys": cloud_config
["key-pairs"] }]
831 if cloud_config
.get("users"):
832 if "users" not in userdata_dict
:
833 userdata_dict
["users"] = [ "default" ]
834 for user
in cloud_config
["users"]:
836 "name" : user
["name"],
837 "sudo": "ALL = (ALL)NOPASSWD:ALL"
839 if "user-info" in user
:
840 user_info
["gecos"] = user
["user-info"]
841 if user
.get("key-pairs"):
842 user_info
["ssh-authorized-keys"] = user
["key-pairs"]
843 userdata_dict
["users"].append(user_info
)
845 if cloud_config
.get("config-files"):
846 userdata_dict
["write_files"] = []
847 for file in cloud_config
["config-files"]:
849 "path" : file["dest"],
850 "content": file["content"]
852 if file.get("encoding"):
853 file_info
["encoding"] = file["encoding"]
854 if file.get("permissions"):
855 file_info
["permissions"] = file["permissions"]
856 if file.get("owner"):
857 file_info
["owner"] = file["owner"]
858 userdata_dict
["write_files"].append(file_info
)
859 userdata
= "#cloud-config\n"
860 userdata
+= yaml
.safe_dump(userdata_dict
, indent
=4, default_flow_style
=False)
861 self
.logger
.debug("userdata: %s", userdata
)
862 elif isinstance(cloud_config
, str):
863 userdata
= cloud_config
865 #Create additional volumes in case these are present in disk_list
866 block_device_mapping
= None
867 base_disk_index
= ord('b')
868 if disk_list
!= None:
869 block_device_mapping
= dict()
870 for disk
in disk_list
:
871 if 'image_id' in disk
:
872 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
873 chr(base_disk_index
), imageRef
= disk
['image_id'])
875 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
876 chr(base_disk_index
))
877 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
880 #wait until volumes are with status available
883 while keep_waiting
and elapsed_time
< volume_timeout
:
885 for volume_id
in block_device_mapping
.itervalues():
886 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
892 #if we exceeded the timeout rollback
893 if elapsed_time
>= volume_timeout
:
894 #delete the volumes we just created
895 for volume_id
in block_device_mapping
.itervalues():
896 self
.cinder
.volumes
.delete(volume_id
)
898 #delete ports we just created
899 for net_item
in net_list_vim
:
900 if 'port-id' in net_item
:
901 self
.neutron
.delete_port(net_item
['port-id'])
903 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
904 http_code
=vimconn
.HTTP_Request_Timeout
)
906 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
907 security_groups
=security_groups
,
908 availability_zone
=self
.config
.get('availability_zone'),
909 key_name
=self
.config
.get('keypair'),
911 config_drive
= config_drive
,
912 block_device_mapping
= block_device_mapping
913 ) # , description=description)
914 #print "DONE :-)", server
916 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
917 for floating_network
in external_network
:
919 # wait until vm is active
921 while elapsed_time
< server_timeout
:
922 status
= self
.nova
.servers
.get(server
.id).status
923 if status
== 'ACTIVE':
928 #if we exceeded the timeout rollback
929 if elapsed_time
>= server_timeout
:
930 raise vimconn
.vimconnException('Timeout creating instance ' + name
,
931 http_code
=vimconn
.HTTP_Request_Timeout
)
934 while(assigned
== False):
936 ip
= floating_ips
.pop(0)
937 if not ip
.get("port_id", False) and ip
.get('tenant_id') == server
.tenant_id
:
938 free_floating_ip
= ip
.get("floating_ip_address")
940 fix_ip
= floating_network
.get('ip')
941 server
.add_floating_ip(free_floating_ip
, fix_ip
)
943 except Exception as e
:
944 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
946 #Find the external network
947 external_nets
= list()
948 for net
in self
.neutron
.list_networks()['networks']:
949 if net
['router:external']:
950 external_nets
.append(net
)
952 if len(external_nets
) == 0:
953 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
954 "network is present",
955 http_code
=vimconn
.HTTP_Conflict
)
956 if len(external_nets
) > 1:
957 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
958 "external networks are present",
959 http_code
=vimconn
.HTTP_Conflict
)
961 pool_id
= external_nets
[0].get('id')
962 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
964 #self.logger.debug("Creating floating IP")
965 new_floating_ip
= self
.neutron
.create_floatingip(param
)
966 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
967 fix_ip
= floating_network
.get('ip')
968 server
.add_floating_ip(free_floating_ip
, fix_ip
)
970 except Exception as e
:
971 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot assign floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
972 except Exception as e
:
973 if not floating_network
['exit_on_floating_ip_error']:
974 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
976 self
.delete_vminstance(server
.id)
980 # except nvExceptions.NotFound as e:
981 # error_value=-vimconn.HTTP_Not_Found
982 # error_text= "vm instance %s not found" % vm_id
983 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
984 # delete the volumes we just created
985 if block_device_mapping
!= None:
986 for volume_id
in block_device_mapping
.itervalues():
987 self
.cinder
.volumes
.delete(volume_id
)
989 # delete ports we just created
990 for net_item
in net_list_vim
:
991 if 'port-id' in net_item
:
992 self
.neutron
.delete_port(net_item
['port-id'])
993 self
._format
_exception
(e
)
994 except TypeError as e
:
995 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
997 def get_vminstance(self
,vm_id
):
998 '''Returns the VM instance information from VIM'''
999 #self.logger.debug("Getting VM from VIM")
1001 self
._reload
_connection
()
1002 server
= self
.nova
.servers
.find(id=vm_id
)
1003 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1004 return server
.to_dict()
1005 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1006 self
._format
_exception
(e
)
1008 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1010 Get a console for the virtual machine
1012 vm_id: uuid of the VM
1013 console_type, can be:
1014 "novnc" (by default), "xvpvnc" for VNC types,
1015 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1016 Returns dict with the console parameters:
1017 protocol: ssh, ftp, http, https, ...
1018 server: usually ip address
1019 port: the http, ssh, ... port
1020 suffix: extra text, e.g. the http path and query string
1022 self
.logger
.debug("Getting VM CONSOLE from VIM")
1024 self
._reload
_connection
()
1025 server
= self
.nova
.servers
.find(id=vm_id
)
1026 if console_type
== None or console_type
== "novnc":
1027 console_dict
= server
.get_vnc_console("novnc")
1028 elif console_type
== "xvpvnc":
1029 console_dict
= server
.get_vnc_console(console_type
)
1030 elif console_type
== "rdp-html5":
1031 console_dict
= server
.get_rdp_console(console_type
)
1032 elif console_type
== "spice-html5":
1033 console_dict
= server
.get_spice_console(console_type
)
1035 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1037 console_dict1
= console_dict
.get("console")
1039 console_url
= console_dict1
.get("url")
1042 protocol_index
= console_url
.find("//")
1043 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1044 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1045 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1046 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1047 console_dict
={"protocol": console_url
[0:protocol_index
],
1048 "server": console_url
[protocol_index
+2:port_index
],
1049 "port": console_url
[port_index
:suffix_index
],
1050 "suffix": console_url
[suffix_index
+1:]
1054 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1056 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1057 self
._format
_exception
(e
)
1059 def delete_vminstance(self
, vm_id
):
1060 '''Removes a VM instance from VIM. Returns the old identifier
1062 #print "osconnector: Getting VM from VIM"
1064 self
._reload
_connection
()
1065 #delete VM ports attached to this networks before the virtual machine
1066 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
1067 for p
in ports
['ports']:
1069 self
.neutron
.delete_port(p
["id"])
1070 except Exception as e
:
1071 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
1073 #commented because detaching the volumes makes the servers.delete not work properly ?!?
1074 #dettach volumes attached
1075 server
= self
.nova
.servers
.get(vm_id
)
1076 volumes_attached_dict
= server
._info
['os-extended-volumes:volumes_attached']
1077 #for volume in volumes_attached_dict:
1078 # self.cinder.volumes.detach(volume['id'])
1080 self
.nova
.servers
.delete(vm_id
)
1083 #Although having detached them should have them in active status
1084 #we ensure in this loop
1087 while keep_waiting
and elapsed_time
< volume_timeout
:
1088 keep_waiting
= False
1089 for volume
in volumes_attached_dict
:
1090 if self
.cinder
.volumes
.get(volume
['id']).status
!= 'available':
1093 self
.cinder
.volumes
.delete(volume
['id'])
1099 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1100 self
._format
_exception
(e
)
1101 #TODO insert exception vimconn.HTTP_Unauthorized
1102 #if reaching here is because an exception
1104 def refresh_vms_status(self
, vm_list
):
1105 '''Get the status of the virtual machines and their interfaces/ports
1106 Params: the list of VM identifiers
1107 Returns a dictionary with:
1108 vm_id: #VIM id of this Virtual Machine
1109 status: #Mandatory. Text with one of:
1110 # DELETED (not found at vim)
1111 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1112 # OTHER (Vim reported other status not understood)
1113 # ERROR (VIM indicates an ERROR status)
1114 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1115 # CREATING (on building process), ERROR
1116 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1118 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1119 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1121 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1122 mac_address: #Text format XX:XX:XX:XX:XX:XX
1123 vim_net_id: #network id where this interface is connected
1124 vim_interface_id: #interface/port VIM id
1125 ip_address: #null, or text with IPv4, IPv6 address
1126 compute_node: #identification of compute node where PF,VF interface is allocated
1127 pci: #PCI address of the NIC that hosts the PF,VF
1128 vlan: #physical VLAN used for VF
1131 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1132 for vm_id
in vm_list
:
1135 vm_vim
= self
.get_vminstance(vm_id
)
1136 if vm_vim
['status'] in vmStatus2manoFormat
:
1137 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1139 vm
['status'] = "OTHER"
1140 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1142 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1143 except yaml
.representer
.RepresenterError
:
1144 vm
['vim_info'] = str(vm_vim
)
1145 vm
["interfaces"] = []
1146 if vm_vim
.get('fault'):
1147 vm
['error_msg'] = str(vm_vim
['fault'])
1150 self
._reload
_connection
()
1151 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
1152 for port
in port_dict
["ports"]:
1155 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1156 except yaml
.representer
.RepresenterError
:
1157 interface
['vim_info'] = str(port
)
1158 interface
["mac_address"] = port
.get("mac_address")
1159 interface
["vim_net_id"] = port
["network_id"]
1160 interface
["vim_interface_id"] = port
["id"]
1161 # check if OS-EXT-SRV-ATTR:host is there,
1162 # in case of non-admin credentials, it will be missing
1163 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1164 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1165 interface
["pci"] = None
1167 # check if binding:profile is there,
1168 # in case of non-admin credentials, it will be missing
1169 if port
.get('binding:profile'):
1170 if port
['binding:profile'].get('pci_slot'):
1171 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1172 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1173 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1174 pci
= port
['binding:profile']['pci_slot']
1175 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1176 interface
["pci"] = pci
1177 interface
["vlan"] = None
1178 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1179 network
= self
.neutron
.show_network(port
["network_id"])
1180 if network
['network'].get('provider:network_type') == 'vlan' and \
1181 port
.get("binding:vnic_type") == "direct":
1182 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1184 #look for floating ip address
1185 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1186 if floating_ip_dict
.get("floatingips"):
1187 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1189 for subnet
in port
["fixed_ips"]:
1190 ips
.append(subnet
["ip_address"])
1191 interface
["ip_address"] = ";".join(ips
)
1192 vm
["interfaces"].append(interface
)
1193 except Exception as e
:
1194 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1195 except vimconn
.vimconnNotFoundException
as e
:
1196 self
.logger
.error("Exception getting vm status: %s", str(e
))
1197 vm
['status'] = "DELETED"
1198 vm
['error_msg'] = str(e
)
1199 except vimconn
.vimconnException
as e
:
1200 self
.logger
.error("Exception getting vm status: %s", str(e
))
1201 vm
['status'] = "VIM_ERROR"
1202 vm
['error_msg'] = str(e
)
1206 def action_vminstance(self
, vm_id
, action_dict
):
1207 '''Send and action over a VM instance from VIM
1208 Returns the vm_id if the action was successfully sent to the VIM'''
1209 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1211 self
._reload
_connection
()
1212 server
= self
.nova
.servers
.find(id=vm_id
)
1213 if "start" in action_dict
:
1214 if action_dict
["start"]=="rebuild":
1217 if server
.status
=="PAUSED":
1219 elif server
.status
=="SUSPENDED":
1221 elif server
.status
=="SHUTOFF":
1223 elif "pause" in action_dict
:
1225 elif "resume" in action_dict
:
1227 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1229 elif "forceOff" in action_dict
:
1231 elif "terminate" in action_dict
:
1233 elif "createImage" in action_dict
:
1234 server
.create_image()
1235 #"path":path_schema,
1236 #"description":description_schema,
1237 #"name":name_schema,
1238 #"metadata":metadata_schema,
1239 #"imageRef": id_schema,
1240 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1241 elif "rebuild" in action_dict
:
1242 server
.rebuild(server
.image
['id'])
1243 elif "reboot" in action_dict
:
1244 server
.reboot() #reboot_type='SOFT'
1245 elif "console" in action_dict
:
1246 console_type
= action_dict
["console"]
1247 if console_type
== None or console_type
== "novnc":
1248 console_dict
= server
.get_vnc_console("novnc")
1249 elif console_type
== "xvpvnc":
1250 console_dict
= server
.get_vnc_console(console_type
)
1251 elif console_type
== "rdp-html5":
1252 console_dict
= server
.get_rdp_console(console_type
)
1253 elif console_type
== "spice-html5":
1254 console_dict
= server
.get_spice_console(console_type
)
1256 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1257 http_code
=vimconn
.HTTP_Bad_Request
)
1259 console_url
= console_dict
["console"]["url"]
1261 protocol_index
= console_url
.find("//")
1262 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1263 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1264 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1265 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1266 console_dict2
={"protocol": console_url
[0:protocol_index
],
1267 "server": console_url
[protocol_index
+2 : port_index
],
1268 "port": int(console_url
[port_index
+1 : suffix_index
]),
1269 "suffix": console_url
[suffix_index
+1:]
1271 return console_dict2
1272 except Exception as e
:
1273 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1276 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1277 self
._format
_exception
(e
)
1278 #TODO insert exception vimconn.HTTP_Unauthorized
1280 ####### VIO Specific Changes #########
1281 def _genrate_vlanID(self
):
1283 Method to get unused vlanID
1291 networks
= self
.get_network_list()
1292 for net
in networks
:
1293 if net
.get('provider:segmentation_id'):
1294 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1295 used_vlanIDs
= set(usedVlanIDs
)
1297 #find unused VLAN ID
1298 for vlanID_range
in self
.config
.get('dataplane_net_vlan_range'):
1300 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1301 for vlanID
in xrange(start_vlanid
, end_vlanid
+ 1):
1302 if vlanID
not in used_vlanIDs
:
1304 except Exception as exp
:
1305 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1307 raise vimconn
.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1308 " All given Vlan IDs {} are in use.".format(self
.config
.get('dataplane_net_vlan_range')))
1311 def _validate_vlan_ranges(self
, dataplane_net_vlan_range
):
1313 Method to validate user given vlanID ranges
1317 for vlanID_range
in dataplane_net_vlan_range
:
1318 vlan_range
= vlanID_range
.replace(" ", "")
1320 vlanID_pattern
= r
'(\d)*-(\d)*$'
1321 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
1323 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}.You must provide "\
1324 "'dataplane_net_vlan_range' in format [start_ID - end_ID].".format(vlanID_range
))
1326 start_vlanid
, end_vlanid
= map(int,vlan_range
.split("-"))
1327 if start_vlanid
<= 0 :
1328 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1329 "Start ID can not be zero. For VLAN "\
1330 "networks valid IDs are 1 to 4094 ".format(vlanID_range
))
1331 if end_vlanid
> 4094 :
1332 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1333 "End VLAN ID can not be greater than 4094. For VLAN "\
1334 "networks valid IDs are 1 to 4094 ".format(vlanID_range
))
1336 if start_vlanid
> end_vlanid
:
1337 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1338 "You must provide a 'dataplane_net_vlan_range' in format start_ID - end_ID and "\
1339 "start_ID < end_ID ".format(vlanID_range
))
1343 def new_external_port(self
, port_data
):
1344 #TODO openstack if needed
1345 '''Adds a external port to VIM'''
1346 '''Returns the port identifier'''
1347 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1349 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1350 #TODO openstack if needed
1351 '''Connects a external port to a network'''
1352 '''Returns status code of the VIM response'''
1353 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1355 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1356 '''Adds a new user to openstack VIM'''
1357 '''Returns the user identifier'''
1358 self
.logger
.debug("osconnector: Adding a new user to VIM")
1360 self
._reload
_connection
()
1361 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1362 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1364 except ksExceptions
.ConnectionError
as e
:
1365 error_value
=-vimconn
.HTTP_Bad_Request
1366 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1367 except ksExceptions
.ClientException
as e
: #TODO remove
1368 error_value
=-vimconn
.HTTP_Bad_Request
1369 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1370 #TODO insert exception vimconn.HTTP_Unauthorized
1371 #if reaching here is because an exception
1373 self
.logger
.debug("new_user " + error_text
)
1374 return error_value
, error_text
1376 def delete_user(self
, user_id
):
1377 '''Delete a user from openstack VIM'''
1378 '''Returns the user identifier'''
1380 print "osconnector: Deleting a user from VIM"
1382 self
._reload
_connection
()
1383 self
.keystone
.users
.delete(user_id
)
1385 except ksExceptions
.ConnectionError
as e
:
1386 error_value
=-vimconn
.HTTP_Bad_Request
1387 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1388 except ksExceptions
.NotFound
as e
:
1389 error_value
=-vimconn
.HTTP_Not_Found
1390 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1391 except ksExceptions
.ClientException
as e
: #TODO remove
1392 error_value
=-vimconn
.HTTP_Bad_Request
1393 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1394 #TODO insert exception vimconn.HTTP_Unauthorized
1395 #if reaching here is because an exception
1397 print "delete_tenant " + error_text
1398 return error_value
, error_text
1400 def get_hosts_info(self
):
1401 '''Get the information of deployed hosts
1402 Returns the hosts content'''
1404 print "osconnector: Getting Host info from VIM"
1407 self
._reload
_connection
()
1408 hypervisors
= self
.nova
.hypervisors
.list()
1409 for hype
in hypervisors
:
1410 h_list
.append( hype
.to_dict() )
1411 return 1, {"hosts":h_list
}
1412 except nvExceptions
.NotFound
as e
:
1413 error_value
=-vimconn
.HTTP_Not_Found
1414 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1415 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1416 error_value
=-vimconn
.HTTP_Bad_Request
1417 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1418 #TODO insert exception vimconn.HTTP_Unauthorized
1419 #if reaching here is because an exception
1421 print "get_hosts_info " + error_text
1422 return error_value
, error_text
1424 def get_hosts(self
, vim_tenant
):
1425 '''Get the hosts and deployed instances
1426 Returns the hosts content'''
1427 r
, hype_dict
= self
.get_hosts_info()
1430 hypervisors
= hype_dict
["hosts"]
1432 servers
= self
.nova
.servers
.list()
1433 for hype
in hypervisors
:
1434 for server
in servers
:
1435 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1437 hype
['vm'].append(server
.id)
1439 hype
['vm'] = [server
.id]
1441 except nvExceptions
.NotFound
as e
:
1442 error_value
=-vimconn
.HTTP_Not_Found
1443 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1444 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1445 error_value
=-vimconn
.HTTP_Bad_Request
1446 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1447 #TODO insert exception vimconn.HTTP_Unauthorized
1448 #if reaching here is because an exception
1450 print "get_hosts " + error_text
1451 return error_value
, error_text