The nova.virt.xenapi.vm_utils Module

Helper methods for operations related to the management of VM records and their attributes like VDIs, VIFs, as well as their lookup functions.

class ImageType

Bases: object

Enumeration class for distinguishing different image types

0 - kernel image (goes on dom0’s filesystem)

1 - ramdisk image (goes on dom0’s filesystem)

2 - disk image (local SR, partitioned by objectstore plugin)

3 - raw disk image (local SR, NOT partitioned by plugin)

4 - vhd disk image (local SR, NOT inspected by XS, PV assumed for

linux, HVM assumed for Windows)

5 - ISO disk image (local SR, NOT partitioned by plugin)

6 - config drive

DISK = 2

DISK_CONFIGDRIVE = 6

DISK_CONFIGDRIVE_STR = 'configdrive'

DISK_ISO = 5

DISK_ISO_STR = 'iso'

DISK_RAW = 3

DISK_RAW_STR = 'os_raw'

DISK_STR = 'root'

DISK_VHD = 4

DISK_VHD_STR = 'vhd'

KERNEL = 0

KERNEL_STR = 'kernel'

RAMDISK = 1

RAMDISK_STR = 'ramdisk'

classmethod get_role(image_type_id)

Get the role played by the image, based on its type.

classmethod to_string(image_type)

auto_configure_disk(session, vdi_ref, new_gb)

Partition and resize FS to match the size specified by instance_types.root_gb.

This is a fail-safe to prevent accidentally destroying data on a disk erroneously marked as auto_disk_config=True.

The criteria for allowing resize are:

1. ‘auto_disk_config’ must be true for the instance (and image). (If we’ve made it here, then auto_disk_config=True.)
2. The disk must have only one partition.
3. The file-system on the one partition must be ext3 or ext4.

clean_shutdown_vm(session, instance, vm_ref)

cleanup_attached_vdis(session)

Unplug any instance VDIs left after an unclean restart.

compile_diagnostics(record)

Compile VM diagnostics data.

compile_info(record)

Fill record with VM status information.

compile_metrics(start_time, stop_time=None)

Compile bandwidth usage, cpu, and disk metrics for all VMs on this host. Note that some stats, like bandwidth, do not seem to be very accurate in some of the data from XenServer (mdragon).

create_kernel_image(context, session, instance, name_label, image_id, image_type)

Creates kernel/ramdisk file from the image stored in the cache. If the image is not present in the cache, it streams it from glance.

Returns: A list of dictionaries that describe VDIs

create_vbd(session, vm_ref, vdi_ref, userdevice, vbd_type='disk', read_only=False, bootable=False, osvol=False)

Create a VBD record and returns its reference.

create_vdi(session, sr_ref, instance, name_label, disk_type, virtual_size, read_only=False)

Create a VDI record and returns its reference.

create_vm(session, instance, name_label, kernel, ramdisk, use_pv_kernel=False)

Create a VM record. Returns new VM reference. the use_pv_kernel flag indicates whether the guest is HVM or PV

There are 3 scenarios:

1. Using paravirtualization, kernel passed in
2. Using paravirtualization, kernel within the image
3. Using hardware virtualization

destroy_cached_images(session, sr_ref, all_cached=False, dry_run=False)

Destroy used or unused cached images.

A cached image that is being used by at least one VM is said to be ‘used’.

In the case of an ‘unused’ image, the cached image will be the only descendent of the base-copy. So when we delete the cached-image, the refcount will drop to zero and XenServer will automatically destroy the base-copy for us.

The default behavior of this function is to destroy only ‘unused’ cached images. To destroy all cached images, use the all_cached=True kwarg.

destroy_kernel_ramdisk(session, kernel, ramdisk)

destroy_vbd(session, vbd_ref)

Destroy VBD from host database.

destroy_vdi(session, vdi_ref)

destroy_vm(session, instance, vm_ref)

Destroys a VM record.

determine_disk_image_type(image_meta)

Disk Image Types are used to determine where the kernel will reside within an image. To figure out which type we’re dealing with, we use the following rules:

1. If we’re using Glance, we can use the image_type field to determine the image_type
2. If we’re not using Glance, then we need to deduce this based on whether a kernel_id is specified.

determine_is_pv(session, vdi_ref, disk_image_type, os_type)

Determine whether the VM will use a paravirtualized kernel or if it will use hardware virtualization.

1. Glance (VHD): then we use os_type, raise if not set
2. Glance (DISK_RAW): use Pygrub to figure out if pv kernel is available
3. Glance (DISK): pv is assumed
4. Glance (DISK_ISO): no pv is assumed
5. Boot From Volume - without image metadata (None): attempt to use Pygrub to figure out if the volume stores a PV VM or a HVM one. Log a warning, because there may be cases where the volume is RAW (in which case using pygrub is fine) and cases where the content of the volume is VHD, and pygrub might not work as expected. NOTE: if disk_image_type is not specified, instances launched from remote volumes will have to include kernel and ramdisk because external kernel and ramdisk will not be fetched.

ensure_correct_host(session)

Ensure we’re connected to the host we’re running on. This is the required configuration for anything that uses vdi_attached_here.

ensure_free_mem(session, instance)

fetch_bandwidth(session)

find_vbd_by_number(session, vm_ref, number)

Get the VBD reference from the device number.

generate_configdrive(session, instance, vm_ref, userdevice, admin_password=None, files=None)

generate_ephemeral(session, instance, vm_ref, userdevice, name_label, size_gb)

generate_swap(session, instance, vm_ref, userdevice, name_label, swap_mb)

get_instance_vdis_for_sr(session, vm_ref, sr_ref)

Return opaqueRef for all the vdis which live on sr.

get_sr_path(session)

Return the path to our storage repository

This is used when we’re dealing with VHDs directly, either by taking snapshots or by restoring an image in the DISK_VHD format.

get_this_vm_uuid()

get_vdi_for_vm_safely(session, vm_ref)

Retrieves the primary VDI for a VM.

get_vdi_uuid_for_volume(session, connection_data)

get_vdis_for_instance(context, session, instance, name_label, image, image_type, block_device_info=None)

hard_shutdown_vm(session, instance, vm_ref)

is_snapshot(session, vm)

list_vms(session)

lookup(session, name_label)

Look the instance up and return it if available.

lookup_kernel_ramdisk(session, vm)

lookup_vm_vdis(session, vm_ref)

Look for the VDIs that are attached to the VM.

move_disks(session, instance, disk_info)

Move and possibly link VHDs via the XAPI plugin.

preconfigure_instance(session, instance, vdi_ref, network_info)

Makes alterations to the image before launching as part of spawn.

resize_disk(session, instance, vdi_ref, instance_type)

safe_destroy_vdis(session, vdi_refs)

Destroys the requested VDIs, logging any StorageError exceptions.

safe_find_sr(session)

Same as _find_sr except raises a NotFound exception if SR cannot be determined

scan_default_sr(session)

Looks for the system default SR and triggers a re-scan.

set_vdi_name(session, vdi_uuid, label, description, vdi_ref=None)

set_vm_name_label(session, vm_ref, name_label)

snapshot_attached_here(*args, **kwds)

unplug_vbd(session, vbd_ref)

Unplug VBD from VM.

vdi_attached_here(*args, **kwds)

vm_ref_or_raise(session, instance_name)