def get_instance_nw_info(self, context, instance):
"""Returns all network info related to an instance."""
args = {
'instance_id': instance['id'],
'instance_uuid': instance['uuid'],
'instance_type_id': instance['instance_type_id'],
'host': instance['host']
}
try:
return rpc.call(context, FLAGS.network_topic, {
'method': 'get_instance_nw_info',
'args': args
})
# FIXME(comstud) rpc calls raise RemoteError if the remote raises
# an exception. In the case here, because of a race condition,
# it's possible the remote will raise a InstanceNotFound when
# someone deletes the instance while this call is in progress.
#
# Unfortunately, we don't have access to the original exception
# class now.. but we do have the exception class's name. So,
# we're checking it here and raising a new exception.
#
# Ultimately we need RPC to be able to serialize more things like
# classes.
except rpc_common.RemoteError as err:
if err.exc_type == 'InstanceNotFound':
raise exception.InstanceNotFound(instance_id=instance['id'])
raise
def get_info(self, instance_name):
"""Return data about the VM instance."""
vm_ref = self._get_vm_ref_from_the_name(instance_name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance_name)
lst_properties = [
"summary.config.numCpu", "summary.config.memorySizeMB",
"runtime.powerState"
]
vm_props = self._session._call_method(vim_util,
"get_object_properties", None,
vm_ref, "VirtualMachine",
lst_properties)
max_mem = None
pwr_state = None
num_cpu = None
for elem in vm_props:
for prop in elem.propSet:
if prop.name == "summary.config.numCpu":
num_cpu = int(prop.val)
elif prop.name == "summary.config.memorySizeMB":
# In MB, but we want in KB
max_mem = int(prop.val) * 1024
elif prop.name == "runtime.powerState":
pwr_state = VMWARE_POWER_STATES[prop.val]
return {
'state': pwr_state,
'max_mem': max_mem,
'mem': max_mem,
'num_cpu': num_cpu,
'cpu_time': 0
}
def get_info(self, instance_name):
"""Get information about the VM"""
vm = self._lookup(instance_name)
if vm is None:
raise exception.InstanceNotFound(instance_id=instance_name)
vm = self._conn.Msvm_ComputerSystem(ElementName=instance_name)[0]
vs_man_svc = self._conn.Msvm_VirtualSystemManagementService()[0]
vmsettings = vm.associators(
wmi_result_class='Msvm_VirtualSystemSettingData')
settings_paths = [v.path_() for v in vmsettings]
#See http://msdn.microsoft.com/en-us/library/cc160706%28VS.85%29.aspx
summary_info = vs_man_svc.GetSummaryInformation([4, 100, 103, 105],
settings_paths)[1]
info = summary_info[0]
state = str(HYPERV_POWER_STATE[info.EnabledState])
memusage = str(info.MemoryUsage)
numprocs = str(info.NumberOfProcessors)
uptime = str(info.UpTime)
LOG.debug(
_("Got Info for vm %(instance_name)s: state=%(state)s,"
" mem=%(memusage)s, num_cpu=%(numprocs)s,"
" cpu_time=%(uptime)s") % locals())
return {
'state': HYPERV_POWER_STATE[info.EnabledState],
'max_mem': info.MemoryUsage,
'mem': info.MemoryUsage,
'num_cpu': info.NumberOfProcessors,
'cpu_time': info.UpTime
}
def generate_password(self, vim_session, pool, instance_name):
"""Returns a VMRC Session.
Return string is of the form '<VM MOID>:<VMRC Ticket>'.
"""
vms = vim_session._call_method(vim_util, 'get_objects',
'VirtualMachine', ['name'])
vm_ref = None
for vm in vms:
if vm.propSet[0].val == instance_name:
vm_ref = vm.obj
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance_name)
virtual_machine_ticket = \
vim_session._call_method(
vim_session._get_vim(),
'AcquireCloneTicket',
vim_session._get_vim().get_service_content().sessionManager)
json_data = json.dumps({
'vm_id': str(vm_ref.value),
'username': virtual_machine_ticket,
'password': virtual_machine_ticket
})
return base64.b64encode(json_data)
def generate_password(self, vim_session, pool, instance_name):
"""Returns VMRC Connection credentials.
Return string is of the form '<VM PATH>:<ESX Username>@<ESX Password>'.
"""
username, password = pool['username'], pool['password']
vms = vim_session._call_method(vim_util, 'get_objects',
'VirtualMachine',
['name', 'config.files.vmPathName'])
vm_ds_path_name = None
vm_ref = None
for vm in vms:
vm_name = None
ds_path_name = None
for prop in vm.propSet:
if prop.name == 'name':
vm_name = prop.val
elif prop.name == 'config.files.vmPathName':
ds_path_name = prop.val
if vm_name == instance_name:
vm_ref = vm.obj
vm_ds_path_name = ds_path_name
break
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance_name)
json_data = json.dumps({
'vm_id': vm_ds_path_name,
'username': username,
'password': password
})
return base64.b64encode(json_data)
def suspend(self, instance):
"""Suspend the specified instance."""
vm_ref = self._get_vm_ref_from_the_name(instance.name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance.id)
pwr_state = self._session._call_method(vim_util,
"get_dynamic_property", vm_ref,
"VirtualMachine",
"runtime.powerState")
# Only PoweredOn VMs can be suspended.
if pwr_state == "poweredOn":
LOG.debug(_("Suspending the VM %s ") % instance.name)
suspend_task = self._session._call_method(self._session._get_vim(),
"SuspendVM_Task", vm_ref)
self._session._wait_for_task(instance['uuid'], suspend_task)
LOG.debug(_("Suspended the VM %s ") % instance.name)
# Raise Exception if VM is poweredOff
elif pwr_state == "poweredOff":
reason = _("instance is powered off and can not be suspended.")
raise exception.InstanceSuspendFailure(reason=reason)
LOG.debug(
_("VM %s was already in suspended state. So returning "
"without doing anything") % instance.name)
def get_info(self, instance_name):
if instance_name not in self.instances:
raise exception.InstanceNotFound(instance_id=instance_name)
i = self.instances[instance_name]
return {'state': i.state,
'max_mem': 0,
'mem': 0,
'num_cpu': 2,
'cpu_time': 0}
def _route_to_child_zones(self, context, collection, item_uuid):
if not FLAGS.enable_zone_routing:
raise exception.InstanceNotFound(instance_id=item_uuid)
self.item_uuid = item_uuid
zones = db.zone_get_all(context)
if not zones:
raise exception.InstanceNotFound(instance_id=item_uuid)
# Ask the children to provide an answer ...
LOG.debug(_("Asking child zones ..."))
result = self._call_child_zones(
context, zones,
wrap_engineclient_function(_issue_engineclient_command, collection,
self.method_name, item_uuid))
# Scrub the results and raise another exception
# so the API layers can bail out gracefully ...
raise RedirectResult(self.unmarshall_result(result))
def _set_machine_id(self, client_factory, instance, network_info):
"""
Set the machine id of the VM for guest tools to pick up and reconfigure
the network interfaces.
"""
vm_ref = self._get_vm_ref_from_the_name(instance.name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance.id)
machine_id_str = ''
for (network, info) in network_info:
# TODO(vish): add support for dns2
# TODO(sateesh): add support for injection of ipv6 configuration
ip_v4 = ip_v6 = None
if 'ips' in info and len(info['ips']) > 0:
ip_v4 = info['ips'][0]
if 'ip6s' in info and len(info['ip6s']) > 0:
ip_v6 = info['ip6s'][0]
if len(info['dns']) > 0:
dns = info['dns'][0]
else:
dns = ''
interface_str = "%s;%s;%s;%s;%s;%s" % \
(info['mac'],
ip_v4 and ip_v4['ip'] or '',
ip_v4 and ip_v4['netmask'] or '',
info['gateway'],
info['broadcast'],
dns)
machine_id_str = machine_id_str + interface_str + '#'
machine_id_change_spec = \
vm_util.get_machine_id_change_spec(client_factory, machine_id_str)
LOG.debug(
_("Reconfiguring VM instance %(name)s to set the machine id "
"with ip - %(ip_addr)s") % ({
'name': instance.name,
'ip_addr': ip_v4['ip']
}))
reconfig_task = self._session._call_method(self._session._get_vim(),
"ReconfigVM_Task",
vm_ref,
spec=machine_id_change_spec)
self._session._wait_for_task(instance['uuid'], reconfig_task)
LOG.debug(
_("Reconfigured VM instance %(name)s to set the machine id "
"with ip - %(ip_addr)s") % ({
'name': instance.name,
'ip_addr': ip_v4['ip']
}))
def detach_volume(self, connection_info, instance_name, mountpoint):
"""Detach volume storage to VM instance"""
# Before we start, check that the VM exists
vm_ref = VMHelper.lookup(self._session, instance_name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance_name)
# Detach VBD from VM
LOG.debug(
_("Detach_volume: %(instance_name)s, %(mountpoint)s") % locals())
device_number = VolumeHelper.mountpoint_to_number(mountpoint)
try:
vbd_ref = VMHelper.find_vbd_by_number(self._session, vm_ref,
device_number)
except StorageError, exc:
LOG.exception(exc)
raise Exception(_('Unable to locate volume %s') % mountpoint)
def attach_volume(self, connection_info, instance_name, mountpoint):
"""Attach volume storage to VM instance"""
# Before we start, check that the VM exists
vm_ref = VMHelper.lookup(self._session, instance_name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance_name)
# NOTE: No Resource Pool concept so far
LOG.debug(
_("Attach_volume: %(connection_info)s, %(instance_name)s,"
" %(mountpoint)s") % locals())
driver_type = connection_info['driver_volume_type']
if driver_type not in ['iscsi', 'xensm']:
raise exception.VolumeDriverNotFound(driver_type=driver_type)
data = connection_info['data']
if 'name_label' not in data:
label = 'tempSR-%s' % data['volume_id']
else:
label = data['name_label']
del data['name_label']
if 'name_description' not in data:
desc = 'Disk-for:%s' % instance_name
else:
desc = data['name_description']
LOG.debug(connection_info)
sr_params = {}
if u'sr_uuid' not in data:
sr_params = VolumeHelper.parse_volume_info(connection_info,
mountpoint)
uuid = "FA15E-D15C-" + str(sr_params['id'])
sr_params['sr_type'] = 'iscsi'
else:
uuid = data['sr_uuid']
for k in data['introduce_sr_keys']:
sr_params[k] = data[k]
sr_params['name_description'] = desc
# Introduce SR
try:
sr_ref = self.introduce_sr(uuid, label, sr_params)
LOG.debug(_('Introduced %(label)s as %(sr_ref)s.') % locals())
except self.XenAPI.Failure, exc:
LOG.exception(exc)
raise StorageError(_('Unable to introduce Storage Repository'))
def reboot(self, instance, network_info):
"""Reboot a VM instance."""
vm_ref = self._get_vm_ref_from_the_name(instance.name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance.id)
self.plug_vifs(instance, network_info)
lst_properties = [
"summary.guest.toolsStatus", "runtime.powerState",
"summary.guest.toolsRunningStatus"
]
props = self._session._call_method(vim_util, "get_object_properties",
None, vm_ref, "VirtualMachine",
lst_properties)
pwr_state = None
tools_status = None
tools_running_status = False
for elem in props:
for prop in elem.propSet:
if prop.name == "runtime.powerState":
pwr_state = prop.val
elif prop.name == "summary.guest.toolsStatus":
tools_status = prop.val
elif prop.name == "summary.guest.toolsRunningStatus":
tools_running_status = prop.val
# Raise an exception if the VM is not powered On.
if pwr_state not in ["poweredOn"]:
reason = _("instance is not powered on")
raise exception.InstanceRebootFailure(reason=reason)
# If latest vmware tools are installed in the VM, and that the tools
# are running, then only do a guest reboot. Otherwise do a hard reset.
if (tools_status == "toolsOk"
and tools_running_status == "guestToolsRunning"):
LOG.debug(_("Rebooting guest OS of VM %s") % instance.name)
self._session._call_method(self._session._get_vim(), "RebootGuest",
vm_ref)
LOG.debug(_("Rebooted guest OS of VM %s") % instance.name)
else:
LOG.debug(_("Doing hard reboot of VM %s") % instance.name)
reset_task = self._session._call_method(self._session._get_vim(),
"ResetVM_Task", vm_ref)
self._session._wait_for_task(instance['uuid'], reset_task)
LOG.debug(_("Did hard reboot of VM %s") % instance.name)
def get_console_output(self, instance):
"""Return snapshot of console."""
vm_ref = self._get_vm_ref_from_the_name(instance.name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance.id)
param_list = {"id": str(vm_ref)}
base_url = "%s://%s/screen?%s" % (self._session._scheme,
self._session._host_ip,
urllib.urlencode(param_list))
request = urllib2.Request(base_url)
base64string = base64.encodestring(
'%s:%s' % (self._session._host_username,
self._session._host_password)).replace('\n', '')
request.add_header("Authorization", "Basic %s" % base64string)
result = urllib2.urlopen(request)
if result.code == 200:
return result.read()
else:
return ""
def resume(self, instance):
"""Resume the specified instance."""
vm_ref = self._get_vm_ref_from_the_name(instance.name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance.id)
pwr_state = self._session._call_method(vim_util,
"get_dynamic_property", vm_ref,
"VirtualMachine",
"runtime.powerState")
if pwr_state.lower() == "suspended":
LOG.debug(_("Resuming the VM %s") % instance.name)
suspend_task = self._session._call_method(self._session._get_vim(),
"PowerOnVM_Task", vm_ref)
self._session._wait_for_task(instance['uuid'], suspend_task)
LOG.debug(_("Resumed the VM %s ") % instance.name)
else:
reason = _("instance is not in a suspended state")
raise exception.InstanceResumeFailure(reason=reason)
def detach_volume(self, connection_info, instance_name, mountpoint):
vm = self._lookup(instance_name)
if vm is None:
raise exception.InstanceNotFound(instance_id=instance_name)
def return_server_nonexistant(context, server_id):
raise exception.InstanceNotFound()
def reboot(self, instance, network_info, reboot_type):
"""Reboot the specified instance."""
vm = self._lookup(instance.name)
if vm is None:
raise exception.InstanceNotFound(instance_id=instance.id)
self._set_vm_state(instance.name, 'Reboot')
def server_not_found(self, instance_id):
raise exception.InstanceNotFound(instance_id=instance_id)
def snapshot(self, context, instance, snapshot_name):
"""
Create snapshot from a running VM instance.
Steps followed are:
1. Get the name of the vmdk file which the VM points to right now.
Can be a chain of snapshots, so we need to know the last in the
chain.
2. Create the snapshot. A new vmdk is created which the VM points to
now. The earlier vmdk becomes read-only.
3. Call CopyVirtualDisk which coalesces the disk chain to form a single
vmdk, rather a .vmdk metadata file and a -flat.vmdk disk data file.
4. Now upload the -flat.vmdk file to the image store.
5. Delete the coalesced .vmdk and -flat.vmdk created.
"""
vm_ref = self._get_vm_ref_from_the_name(instance.name)
if vm_ref is None:
raise exception.InstanceNotFound(instance_id=instance.id)
client_factory = self._session._get_vim().client.factory
service_content = self._session._get_vim().get_service_content()
def _get_vm_and_vmdk_attribs():
# Get the vmdk file name that the VM is pointing to
hardware_devices = self._session._call_method(
vim_util, "get_dynamic_property", vm_ref, "VirtualMachine",
"config.hardware.device")
vmdk_file_path_before_snapshot, adapter_type = \
vm_util.get_vmdk_file_path_and_adapter_type(client_factory,
hardware_devices)
datastore_name = vm_util.split_datastore_path(
vmdk_file_path_before_snapshot)[0]
os_type = self._session._call_method(vim_util,
"get_dynamic_property",
vm_ref, "VirtualMachine",
"summary.config.guestId")
return (vmdk_file_path_before_snapshot, adapter_type,
datastore_name, os_type)
vmdk_file_path_before_snapshot, adapter_type, datastore_name,\
os_type = _get_vm_and_vmdk_attribs()
def _create_vm_snapshot():
# Create a snapshot of the VM
LOG.debug(
_("Creating Snapshot of the VM instance %s ") % instance.name)
snapshot_task = self._session._call_method(
self._session._get_vim(),
"CreateSnapshot_Task",
vm_ref,
name="%s-snapshot" % instance.name,
description="Taking Snapshot of the VM",
memory=True,
quiesce=True)
self._session._wait_for_task(instance['uuid'], snapshot_task)
LOG.debug(
_("Created Snapshot of the VM instance %s ") % instance.name)
_create_vm_snapshot()
def _check_if_tmp_folder_exists():
# Copy the contents of the VM that were there just before the
# snapshot was taken
ds_ref_ret = vim_util.get_dynamic_property(
self._session._get_vim(), vm_ref, "VirtualMachine",
"datastore")
if not ds_ref_ret:
raise exception.DatastoreNotFound()
ds_ref = ds_ref_ret.ManagedObjectReference[0]
ds_browser = vim_util.get_dynamic_property(
self._session._get_vim(), ds_ref, "Datastore", "browser")
# Check if the vmware-tmp folder exists or not. If not, create one
tmp_folder_path = vm_util.build_datastore_path(
datastore_name, "vmware-tmp")
if not self._path_exists(ds_browser, tmp_folder_path):
self._mkdir(
vm_util.build_datastore_path(datastore_name, "vmware-tmp"))
_check_if_tmp_folder_exists()
# Generate a random vmdk file name to which the coalesced vmdk content
# will be copied to. A random name is chosen so that we don't have
# name clashes.
random_name = str(uuid.uuid4())
dest_vmdk_file_location = vm_util.build_datastore_path(
datastore_name, "vmware-tmp/%s.vmdk" % random_name)
dc_ref = self._get_datacenter_name_and_ref()[0]
def _copy_vmdk_content():
# Copy the contents of the disk ( or disks, if there were snapshots
# done earlier) to a temporary vmdk file.
copy_spec = vm_util.get_copy_virtual_disk_spec(
client_factory, adapter_type)
LOG.debug(
_("Copying disk data before snapshot of the VM "
" instance %s") % instance.name)
copy_disk_task = self._session._call_method(
self._session._get_vim(),
"CopyVirtualDisk_Task",
service_content.virtualDiskManager,
sourceName=vmdk_file_path_before_snapshot,
sourceDatacenter=dc_ref,
destName=dest_vmdk_file_location,
destDatacenter=dc_ref,
destSpec=copy_spec,
force=False)
self._session._wait_for_task(instance['uuid'], copy_disk_task)
LOG.debug(
_("Copied disk data before snapshot of the VM "
"instance %s") % instance.name)
_copy_vmdk_content()
cookies = self._session._get_vim().client.options.transport.cookiejar
def _upload_vmdk_to_image_repository():
# Upload the contents of -flat.vmdk file which has the disk data.
LOG.debug(_("Uploading image %s") % snapshot_name)
vmware_images.upload_image(
context,
snapshot_name,
instance,
os_type=os_type,
adapter_type=adapter_type,
image_version=1,
host=self._session._host_ip,
data_center_name=self._get_datacenter_name_and_ref()[1],
datastore_name=datastore_name,
cookies=cookies,
file_path="vmware-tmp/%s-flat.vmdk" % random_name)
LOG.debug(_("Uploaded image %s") % snapshot_name)
_upload_vmdk_to_image_repository()
def _clean_temp_data():
"""
Delete temporary vmdk files generated in image handling
operations.
"""
# Delete the temporary vmdk created above.
LOG.debug(
_("Deleting temporary vmdk file %s") % dest_vmdk_file_location)
remove_disk_task = self._session._call_method(
self._session._get_vim(),
"DeleteVirtualDisk_Task",
service_content.virtualDiskManager,
name=dest_vmdk_file_location,
datacenter=dc_ref)
self._session._wait_for_task(instance['uuid'], remove_disk_task)
LOG.debug(
_("Deleted temporary vmdk file %s") % dest_vmdk_file_location)
_clean_temp_data()
def fake_compute_get(*args, **kwargs):
raise exception.InstanceNotFound()
def fake_delete_console(cons_self, context, instance_id, console_id):
raise exception.InstanceNotFound(instance_id=instance_id)
def not_found(context):
raise exception.InstanceNotFound(instance_id=5)