1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
3
# Copyright (c) 2011 Citrix Systems, Inc.
4
# Copyright 2011 OpenStack LLC.
6
# Licensed under the Apache License, Version 2.0 (the "License"); you may
7
# not use this file except in compliance with the License. You may obtain
8
# a copy of the License at
10
# http://www.apache.org/licenses/LICENSE-2.0
12
# Unless required by applicable law or agreed to in writing, software
13
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15
# License for the specific language governing permissions and limitations
19
A connection to the VMware ESX platform.
23
:vmwareapi_host_ip: IPAddress of VMware ESX server.
24
:vmwareapi_host_username: Username for connection to VMware ESX Server.
25
:vmwareapi_host_password: Password for connection to VMware ESX Server.
26
:vmwareapi_task_poll_interval: The interval (seconds) used for polling of
29
:vmwareapi_api_retry_count: The API retry count in case of failure such as
30
network failures (socket errors etc.)
37
from eventlet import event
39
from nova import exception
40
from nova import flags
41
from nova.openstack.common import cfg
42
from nova.openstack.common import log as logging
43
from nova import utils
44
from nova.virt import driver
45
from nova.virt.vmwareapi import error_util
46
from nova.virt.vmwareapi import vim
47
from nova.virt.vmwareapi import vim_util
48
from nova.virt.vmwareapi import vmops
51
LOG = logging.getLogger(__name__)
54
cfg.StrOpt('vmwareapi_host_ip',
56
help='URL for connection to VMWare ESX host.Required if '
57
'connection_type is vmwareapi.'),
58
cfg.StrOpt('vmwareapi_host_username',
60
help='Username for connection to VMWare ESX host. '
61
'Used only if connection_type is vmwareapi.'),
62
cfg.StrOpt('vmwareapi_host_password',
64
help='Password for connection to VMWare ESX host. '
65
'Used only if connection_type is vmwareapi.'),
66
cfg.FloatOpt('vmwareapi_task_poll_interval',
68
help='The interval used for polling of remote tasks. '
69
'Used only if connection_type is vmwareapi'),
70
cfg.IntOpt('vmwareapi_api_retry_count',
72
help='The number of times we retry on failures, e.g., '
74
'Used only if connection_type is vmwareapi'),
75
cfg.StrOpt('vmwareapi_vlan_interface',
77
help='Physical ethernet adapter name for vlan networking'),
81
FLAGS.register_opts(vmwareapi_opts)
83
TIME_BETWEEN_API_CALL_RETRIES = 2.0
86
class Failure(Exception):
87
"""Base Exception class for handling task failures."""
89
def __init__(self, details):
90
self.details = details
93
return str(self.details)
96
class VMWareESXDriver(driver.ComputeDriver):
97
"""The ESX host connection object."""
99
def __init__(self, read_only=False, scheme="https"):
100
super(VMWareESXDriver, self).__init__()
102
host_ip = FLAGS.vmwareapi_host_ip
103
host_username = FLAGS.vmwareapi_host_username
104
host_password = FLAGS.vmwareapi_host_password
105
api_retry_count = FLAGS.vmwareapi_api_retry_count
106
if not host_ip or host_username is None or host_password is None:
107
raise Exception(_("Must specify vmwareapi_host_ip,"
108
"vmwareapi_host_username "
109
"and vmwareapi_host_password to use"
110
"connection_type=vmwareapi"))
112
session = VMWareAPISession(host_ip, host_username, host_password,
113
api_retry_count, scheme=scheme)
114
self._vmops = vmops.VMWareVMOps(session)
116
def init_host(self, host):
117
"""Do the initialization that needs to be done."""
118
# FIXME(sateesh): implement this
121
def list_instances(self):
122
"""List VM instances."""
123
return self._vmops.list_instances()
125
def spawn(self, context, instance, image_meta, network_info,
126
block_device_mapping=None):
127
"""Create VM instance."""
128
self._vmops.spawn(context, instance, image_meta, network_info)
130
def snapshot(self, context, instance, name):
131
"""Create snapshot from a running VM instance."""
132
self._vmops.snapshot(context, instance, name)
134
def reboot(self, instance, network_info, reboot_type):
135
"""Reboot VM instance."""
136
self._vmops.reboot(instance, network_info)
138
def destroy(self, instance, network_info, block_device_info=None):
139
"""Destroy VM instance."""
140
self._vmops.destroy(instance, network_info)
142
def pause(self, instance):
143
"""Pause VM instance."""
144
self._vmops.pause(instance)
146
def unpause(self, instance):
147
"""Unpause paused VM instance."""
148
self._vmops.unpause(instance)
150
def suspend(self, instance):
151
"""Suspend the specified instance."""
152
self._vmops.suspend(instance)
154
def resume(self, instance):
155
"""Resume the suspended VM instance."""
156
self._vmops.resume(instance)
158
def get_info(self, instance):
159
"""Return info about the VM instance."""
160
return self._vmops.get_info(instance)
162
def get_diagnostics(self, instance):
163
"""Return data about VM diagnostics."""
164
return self._vmops.get_info(instance)
166
def get_console_output(self, instance):
167
"""Return snapshot of console."""
168
return self._vmops.get_console_output(instance)
170
def get_volume_connector(self, _instance):
171
"""Return volume connector information"""
172
# TODO(vish): When volume attaching is supported, return the
173
# proper initiator iqn and host.
175
'ip': FLAGS.vmwareapi_host_ip,
180
def attach_volume(self, connection_info, instance_name, mountpoint):
181
"""Attach volume storage to VM instance."""
184
def detach_volume(self, connection_info, instance_name, mountpoint):
185
"""Detach volume storage to VM instance."""
188
def get_console_pool_info(self, console_type):
189
"""Get info about the host on which the VM resides."""
190
return {'address': FLAGS.vmwareapi_host_ip,
191
'username': FLAGS.vmwareapi_host_username,
192
'password': FLAGS.vmwareapi_host_password}
194
def update_available_resource(self, ctxt, host):
195
"""This method is supported only by libvirt."""
198
def host_power_action(self, host, action):
199
"""Reboots, shuts down or powers up the host."""
200
raise NotImplementedError()
202
def host_maintenance_mode(self, host, mode):
203
"""Start/Stop host maintenance window. On start, it triggers
204
guest VMs evacuation."""
205
raise NotImplementedError()
207
def set_host_enabled(self, host, enabled):
208
"""Sets the specified host's ability to accept new instances."""
209
raise NotImplementedError()
211
def plug_vifs(self, instance, network_info):
212
"""Plug VIFs into networks."""
213
self._vmops.plug_vifs(instance, network_info)
215
def unplug_vifs(self, instance, network_info):
216
"""Unplug VIFs from networks."""
217
self._vmops.unplug_vifs(instance, network_info)
220
class VMWareAPISession(object):
222
Sets up a session with the ESX host and handles all
223
the calls made to the host.
226
def __init__(self, host_ip, host_username, host_password,
227
api_retry_count, scheme="https"):
228
self._host_ip = host_ip
229
self._host_username = host_username
230
self._host_password = host_password
231
self.api_retry_count = api_retry_count
232
self._scheme = scheme
233
self._session_id = None
235
self._create_session()
237
def _get_vim_object(self):
238
"""Create the VIM Object instance."""
239
return vim.Vim(protocol=self._scheme, host=self._host_ip)
241
def _create_session(self):
242
"""Creates a session with the ESX host."""
245
# Login and setup the session with the ESX host for making
247
self.vim = self._get_vim_object()
248
session = self.vim.Login(
249
self.vim.get_service_content().sessionManager,
250
userName=self._host_username,
251
password=self._host_password)
252
# Terminate the earlier session, if possible ( For the sake of
253
# preserving sessions as there is a limit to the number of
254
# sessions we can have )
257
self.vim.TerminateSession(
258
self.vim.get_service_content().sessionManager,
259
sessionId=[self._session_id])
260
except Exception, excep:
261
# This exception is something we can live with. It is
262
# just an extra caution on our side. The session may
263
# have been cleared. We could have made a call to
264
# SessionIsActive, but that is an overhead because we
265
# anyway would have to call TerminateSession.
267
self._session_id = session.key
269
except Exception, excep:
270
LOG.critical(_("In vmwareapi:_create_session, "
271
"got this exception: %s") % excep)
272
raise exception.NovaException(excep)
275
"""Logs-out the session."""
276
# Logout to avoid un-necessary increase in session count at the
279
self.vim.Logout(self.vim.get_service_content().sessionManager)
280
except Exception, excep:
281
# It is just cautionary on our part to do a logout in del just
282
# to ensure that the session is not left active.
285
def _is_vim_object(self, module):
286
"""Check if the module is a VIM Object instance."""
287
return isinstance(module, vim.Vim)
289
def _call_method(self, module, method, *args, **kwargs):
291
Calls a method within the module specified with
300
if not self._is_vim_object(module):
301
# If it is not the first try, then get the latest
305
args = [self.vim] + args
309
for method_elem in method.split("."):
310
temp_module = getattr(temp_module, method_elem)
312
return temp_module(*args, **kwargs)
313
except error_util.VimFaultException, excep:
314
# If it is a Session Fault Exception, it may point
315
# to a session gone bad. So we try re-creating a session
316
# and then proceeding ahead with the call.
318
if error_util.FAULT_NOT_AUTHENTICATED in excep.fault_list:
319
# Because of the idle session returning an empty
320
# RetrievePropertiesResponse and also the same is returned
321
# when there is say empty answer to the query for
322
# VMs on the host ( as in no VMs on the host), we have no
323
# way to differentiate.
324
# So if the previous response was also am empty response
325
# and after creating a new session, we get the same empty
326
# response, then we are sure of the response being supposed
328
if error_util.FAULT_NOT_AUTHENTICATED in last_fault_list:
330
last_fault_list = excep.fault_list
331
self._create_session()
333
# No re-trying for errors for API call has gone through
334
# and is the caller's fault. Caller should handle these
335
# errors. e.g, InvalidArgument fault.
337
except error_util.SessionOverLoadException, excep:
338
# For exceptions which may come because of session overload,
341
except Exception, excep:
342
# If it is a proper exception, say not having furnished
343
# proper data in the SOAP call or the retry limit having
344
# exceeded, we raise the exception
347
# If retry count has been reached then break and
348
# raise the exception
349
if retry_count > self.api_retry_count:
351
time.sleep(TIME_BETWEEN_API_CALL_RETRIES)
353
LOG.critical(_("In vmwareapi:_call_method, "
354
"got this exception: %s") % exc)
358
"""Gets the VIM object reference."""
360
self._create_session()
363
def _wait_for_task(self, instance_uuid, task_ref):
365
Return a Deferred that will give the result of the given task.
366
The task is polled until it completes.
369
loop = utils.LoopingCall(self._poll_task, instance_uuid, task_ref,
371
loop.start(FLAGS.vmwareapi_task_poll_interval)
372
ret_val = done.wait()
376
def _poll_task(self, instance_uuid, task_ref, done):
378
Poll the given task, and fires the given Deferred if we
382
task_info = self._call_method(vim_util, "get_dynamic_property",
383
task_ref, "Task", "info")
384
task_name = task_info.name
385
if task_info.state in ['queued', 'running']:
387
elif task_info.state == 'success':
388
LOG.debug(_("Task [%(task_name)s] %(task_ref)s "
389
"status: success") % locals())
392
error_info = str(task_info.error.localizedMessage)
393
LOG.warn(_("Task [%(task_name)s] %(task_ref)s "
394
"status: error %(error_info)s") % locals())
395
done.send_exception(exception.NovaException(error_info))
396
except Exception, excep:
397
LOG.warn(_("In vmwareapi:_poll_task, Got this error %s") % excep)
398
done.send_exception(excep)
added
removed
nova/virt/vmwareapi_conn.py
