cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ahu...@apache.org
Subject [03/19] Revert "Applied Tina's patches for removing the xapi jar"
Date Tue, 08 Apr 2014 07:03:44 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/ec102ec9/deps/XenServerJava/src/com/xensource/xenapi/VM.java
----------------------------------------------------------------------
diff --git a/deps/XenServerJava/src/com/xensource/xenapi/VM.java b/deps/XenServerJava/src/com/xensource/xenapi/VM.java
new file mode 100644
index 0000000..6ed76af
--- /dev/null
+++ b/deps/XenServerJava/src/com/xensource/xenapi/VM.java
@@ -0,0 +1,4956 @@
+/*
+ * Copyright (c) Citrix Systems, Inc.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ *   1) Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ * 
+ *   2) Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials
+ *      provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+package com.xensource.xenapi;
+
+import com.xensource.xenapi.Types.BadServerResponse;
+import com.xensource.xenapi.Types.VersionException;
+import com.xensource.xenapi.Types.XenAPIException;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.xmlrpc.XmlRpcException;
+
+/**
+ * A virtual machine (or 'guest').
+ *
+ * @author Citrix Systems, Inc.
+ */
+public class VM extends XenAPIObject {
+
+    /**
+     * The XenAPI reference (OpaqueRef) to this object.
+     */
+    protected final String ref;
+
+    /**
+     * For internal use only.
+     */
+    VM(String ref) {
+       this.ref = ref;
+    }
+
+    /**
+     * @return The XenAPI reference (OpaqueRef) to this object.
+     */
+    public String toWireString() {
+       return this.ref;
+    }
+
+    /**
+     * If obj is a VM, compares XenAPI references for equality.
+     */
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (obj != null && obj instanceof VM)
+        {
+            VM other = (VM) obj;
+            return other.ref.equals(this.ref);
+        } else
+        {
+            return false;
+        }
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return ref.hashCode();
+    }
+
+    /**
+     * Represents all the fields in a VM
+     */
+    public static class Record implements Types.Record {
+        public String toString() {
+            StringWriter writer = new StringWriter();
+            PrintWriter print = new PrintWriter(writer);
+            print.printf("%1$20s: %2$s\n", "uuid", this.uuid);
+            print.printf("%1$20s: %2$s\n", "allowedOperations", this.allowedOperations);
+            print.printf("%1$20s: %2$s\n", "currentOperations", this.currentOperations);
+            print.printf("%1$20s: %2$s\n", "powerState", this.powerState);
+            print.printf("%1$20s: %2$s\n", "nameLabel", this.nameLabel);
+            print.printf("%1$20s: %2$s\n", "nameDescription", this.nameDescription);
+            print.printf("%1$20s: %2$s\n", "userVersion", this.userVersion);
+            print.printf("%1$20s: %2$s\n", "isATemplate", this.isATemplate);
+            print.printf("%1$20s: %2$s\n", "suspendVDI", this.suspendVDI);
+            print.printf("%1$20s: %2$s\n", "residentOn", this.residentOn);
+            print.printf("%1$20s: %2$s\n", "affinity", this.affinity);
+            print.printf("%1$20s: %2$s\n", "memoryOverhead", this.memoryOverhead);
+            print.printf("%1$20s: %2$s\n", "memoryTarget", this.memoryTarget);
+            print.printf("%1$20s: %2$s\n", "memoryStaticMax", this.memoryStaticMax);
+            print.printf("%1$20s: %2$s\n", "memoryDynamicMax", this.memoryDynamicMax);
+            print.printf("%1$20s: %2$s\n", "memoryDynamicMin", this.memoryDynamicMin);
+            print.printf("%1$20s: %2$s\n", "memoryStaticMin", this.memoryStaticMin);
+            print.printf("%1$20s: %2$s\n", "VCPUsParams", this.VCPUsParams);
+            print.printf("%1$20s: %2$s\n", "VCPUsMax", this.VCPUsMax);
+            print.printf("%1$20s: %2$s\n", "VCPUsAtStartup", this.VCPUsAtStartup);
+            print.printf("%1$20s: %2$s\n", "actionsAfterShutdown", this.actionsAfterShutdown);
+            print.printf("%1$20s: %2$s\n", "actionsAfterReboot", this.actionsAfterReboot);
+            print.printf("%1$20s: %2$s\n", "actionsAfterCrash", this.actionsAfterCrash);
+            print.printf("%1$20s: %2$s\n", "consoles", this.consoles);
+            print.printf("%1$20s: %2$s\n", "VIFs", this.VIFs);
+            print.printf("%1$20s: %2$s\n", "VBDs", this.VBDs);
+            print.printf("%1$20s: %2$s\n", "crashDumps", this.crashDumps);
+            print.printf("%1$20s: %2$s\n", "VTPMs", this.VTPMs);
+            print.printf("%1$20s: %2$s\n", "PVBootloader", this.PVBootloader);
+            print.printf("%1$20s: %2$s\n", "PVKernel", this.PVKernel);
+            print.printf("%1$20s: %2$s\n", "PVRamdisk", this.PVRamdisk);
+            print.printf("%1$20s: %2$s\n", "PVArgs", this.PVArgs);
+            print.printf("%1$20s: %2$s\n", "PVBootloaderArgs", this.PVBootloaderArgs);
+            print.printf("%1$20s: %2$s\n", "PVLegacyArgs", this.PVLegacyArgs);
+            print.printf("%1$20s: %2$s\n", "HVMBootPolicy", this.HVMBootPolicy);
+            print.printf("%1$20s: %2$s\n", "HVMBootParams", this.HVMBootParams);
+            print.printf("%1$20s: %2$s\n", "HVMShadowMultiplier", this.HVMShadowMultiplier);
+            print.printf("%1$20s: %2$s\n", "platform", this.platform);
+            print.printf("%1$20s: %2$s\n", "PCIBus", this.PCIBus);
+            print.printf("%1$20s: %2$s\n", "otherConfig", this.otherConfig);
+            print.printf("%1$20s: %2$s\n", "domid", this.domid);
+            print.printf("%1$20s: %2$s\n", "domarch", this.domarch);
+            print.printf("%1$20s: %2$s\n", "lastBootCPUFlags", this.lastBootCPUFlags);
+            print.printf("%1$20s: %2$s\n", "isControlDomain", this.isControlDomain);
+            print.printf("%1$20s: %2$s\n", "metrics", this.metrics);
+            print.printf("%1$20s: %2$s\n", "guestMetrics", this.guestMetrics);
+            print.printf("%1$20s: %2$s\n", "lastBootedRecord", this.lastBootedRecord);
+            print.printf("%1$20s: %2$s\n", "recommendations", this.recommendations);
+            print.printf("%1$20s: %2$s\n", "xenstoreData", this.xenstoreData);
+            print.printf("%1$20s: %2$s\n", "haAlwaysRun", this.haAlwaysRun);
+            print.printf("%1$20s: %2$s\n", "haRestartPriority", this.haRestartPriority);
+            print.printf("%1$20s: %2$s\n", "isASnapshot", this.isASnapshot);
+            print.printf("%1$20s: %2$s\n", "snapshotOf", this.snapshotOf);
+            print.printf("%1$20s: %2$s\n", "snapshots", this.snapshots);
+            print.printf("%1$20s: %2$s\n", "snapshotTime", this.snapshotTime);
+            print.printf("%1$20s: %2$s\n", "transportableSnapshotId", this.transportableSnapshotId);
+            print.printf("%1$20s: %2$s\n", "blobs", this.blobs);
+            print.printf("%1$20s: %2$s\n", "tags", this.tags);
+            print.printf("%1$20s: %2$s\n", "blockedOperations", this.blockedOperations);
+            print.printf("%1$20s: %2$s\n", "snapshotInfo", this.snapshotInfo);
+            print.printf("%1$20s: %2$s\n", "snapshotMetadata", this.snapshotMetadata);
+            print.printf("%1$20s: %2$s\n", "parent", this.parent);
+            print.printf("%1$20s: %2$s\n", "children", this.children);
+            print.printf("%1$20s: %2$s\n", "biosStrings", this.biosStrings);
+            print.printf("%1$20s: %2$s\n", "protectionPolicy", this.protectionPolicy);
+            print.printf("%1$20s: %2$s\n", "isSnapshotFromVmpp", this.isSnapshotFromVmpp);
+            print.printf("%1$20s: %2$s\n", "appliance", this.appliance);
+            print.printf("%1$20s: %2$s\n", "startDelay", this.startDelay);
+            print.printf("%1$20s: %2$s\n", "shutdownDelay", this.shutdownDelay);
+            print.printf("%1$20s: %2$s\n", "order", this.order);
+            print.printf("%1$20s: %2$s\n", "VGPUs", this.VGPUs);
+            print.printf("%1$20s: %2$s\n", "attachedPCIs", this.attachedPCIs);
+            print.printf("%1$20s: %2$s\n", "suspendSR", this.suspendSR);
+            print.printf("%1$20s: %2$s\n", "version", this.version);
+            print.printf("%1$20s: %2$s\n", "generationId", this.generationId);
+            return writer.toString();
+        }
+
+        /**
+         * Convert a VM.Record to a Map
+         */
+        public Map<String,Object> toMap() {
+            Map<String,Object> map = new HashMap<String,Object>();
+            map.put("uuid", this.uuid == null ? "" : this.uuid);
+            map.put("allowed_operations", this.allowedOperations == null ? new LinkedHashSet<Types.VmOperations>() : this.allowedOperations);
+            map.put("current_operations", this.currentOperations == null ? new HashMap<String, Types.VmOperations>() : this.currentOperations);
+            map.put("power_state", this.powerState == null ? Types.VmPowerState.UNRECOGNIZED : this.powerState);
+            map.put("name_label", this.nameLabel == null ? "" : this.nameLabel);
+            map.put("name_description", this.nameDescription == null ? "" : this.nameDescription);
+            map.put("user_version", this.userVersion == null ? 0 : this.userVersion);
+            map.put("is_a_template", this.isATemplate == null ? false : this.isATemplate);
+            map.put("suspend_VDI", this.suspendVDI == null ? new VDI("OpaqueRef:NULL") : this.suspendVDI);
+            map.put("resident_on", this.residentOn == null ? new Host("OpaqueRef:NULL") : this.residentOn);
+            map.put("affinity", this.affinity == null ? new Host("OpaqueRef:NULL") : this.affinity);
+            map.put("memory_overhead", this.memoryOverhead == null ? 0 : this.memoryOverhead);
+            map.put("memory_target", this.memoryTarget == null ? 0 : this.memoryTarget);
+            map.put("memory_static_max", this.memoryStaticMax == null ? 0 : this.memoryStaticMax);
+            map.put("memory_dynamic_max", this.memoryDynamicMax == null ? 0 : this.memoryDynamicMax);
+            map.put("memory_dynamic_min", this.memoryDynamicMin == null ? 0 : this.memoryDynamicMin);
+            map.put("memory_static_min", this.memoryStaticMin == null ? 0 : this.memoryStaticMin);
+            map.put("VCPUs_params", this.VCPUsParams == null ? new HashMap<String, String>() : this.VCPUsParams);
+            map.put("VCPUs_max", this.VCPUsMax == null ? 0 : this.VCPUsMax);
+            map.put("VCPUs_at_startup", this.VCPUsAtStartup == null ? 0 : this.VCPUsAtStartup);
+            map.put("actions_after_shutdown", this.actionsAfterShutdown == null ? Types.OnNormalExit.UNRECOGNIZED : this.actionsAfterShutdown);
+            map.put("actions_after_reboot", this.actionsAfterReboot == null ? Types.OnNormalExit.UNRECOGNIZED : this.actionsAfterReboot);
+            map.put("actions_after_crash", this.actionsAfterCrash == null ? Types.OnCrashBehaviour.UNRECOGNIZED : this.actionsAfterCrash);
+            map.put("consoles", this.consoles == null ? new LinkedHashSet<Console>() : this.consoles);
+            map.put("VIFs", this.VIFs == null ? new LinkedHashSet<VIF>() : this.VIFs);
+            map.put("VBDs", this.VBDs == null ? new LinkedHashSet<VBD>() : this.VBDs);
+            map.put("crash_dumps", this.crashDumps == null ? new LinkedHashSet<Crashdump>() : this.crashDumps);
+            map.put("VTPMs", this.VTPMs == null ? new LinkedHashSet<VTPM>() : this.VTPMs);
+            map.put("PV_bootloader", this.PVBootloader == null ? "" : this.PVBootloader);
+            map.put("PV_kernel", this.PVKernel == null ? "" : this.PVKernel);
+            map.put("PV_ramdisk", this.PVRamdisk == null ? "" : this.PVRamdisk);
+            map.put("PV_args", this.PVArgs == null ? "" : this.PVArgs);
+            map.put("PV_bootloader_args", this.PVBootloaderArgs == null ? "" : this.PVBootloaderArgs);
+            map.put("PV_legacy_args", this.PVLegacyArgs == null ? "" : this.PVLegacyArgs);
+            map.put("HVM_boot_policy", this.HVMBootPolicy == null ? "" : this.HVMBootPolicy);
+            map.put("HVM_boot_params", this.HVMBootParams == null ? new HashMap<String, String>() : this.HVMBootParams);
+            map.put("HVM_shadow_multiplier", this.HVMShadowMultiplier == null ? 0.0 : this.HVMShadowMultiplier);
+            map.put("platform", this.platform == null ? new HashMap<String, String>() : this.platform);
+            map.put("PCI_bus", this.PCIBus == null ? "" : this.PCIBus);
+            map.put("other_config", this.otherConfig == null ? new HashMap<String, String>() : this.otherConfig);
+            map.put("domid", this.domid == null ? 0 : this.domid);
+            map.put("domarch", this.domarch == null ? "" : this.domarch);
+            map.put("last_boot_CPU_flags", this.lastBootCPUFlags == null ? new HashMap<String, String>() : this.lastBootCPUFlags);
+            map.put("is_control_domain", this.isControlDomain == null ? false : this.isControlDomain);
+            map.put("metrics", this.metrics == null ? new VMMetrics("OpaqueRef:NULL") : this.metrics);
+            map.put("guest_metrics", this.guestMetrics == null ? new VMGuestMetrics("OpaqueRef:NULL") : this.guestMetrics);
+            map.put("last_booted_record", this.lastBootedRecord == null ? "" : this.lastBootedRecord);
+            map.put("recommendations", this.recommendations == null ? "" : this.recommendations);
+            map.put("xenstore_data", this.xenstoreData == null ? new HashMap<String, String>() : this.xenstoreData);
+            map.put("ha_always_run", this.haAlwaysRun == null ? false : this.haAlwaysRun);
+            map.put("ha_restart_priority", this.haRestartPriority == null ? "" : this.haRestartPriority);
+            map.put("is_a_snapshot", this.isASnapshot == null ? false : this.isASnapshot);
+            map.put("snapshot_of", this.snapshotOf == null ? new VM("OpaqueRef:NULL") : this.snapshotOf);
+            map.put("snapshots", this.snapshots == null ? new LinkedHashSet<VM>() : this.snapshots);
+            map.put("snapshot_time", this.snapshotTime == null ? new Date(0) : this.snapshotTime);
+            map.put("transportable_snapshot_id", this.transportableSnapshotId == null ? "" : this.transportableSnapshotId);
+            map.put("blobs", this.blobs == null ? new HashMap<String, Blob>() : this.blobs);
+            map.put("tags", this.tags == null ? new LinkedHashSet<String>() : this.tags);
+            map.put("blocked_operations", this.blockedOperations == null ? new HashMap<Types.VmOperations, String>() : this.blockedOperations);
+            map.put("snapshot_info", this.snapshotInfo == null ? new HashMap<String, String>() : this.snapshotInfo);
+            map.put("snapshot_metadata", this.snapshotMetadata == null ? "" : this.snapshotMetadata);
+            map.put("parent", this.parent == null ? new VM("OpaqueRef:NULL") : this.parent);
+            map.put("children", this.children == null ? new LinkedHashSet<VM>() : this.children);
+            map.put("bios_strings", this.biosStrings == null ? new HashMap<String, String>() : this.biosStrings);
+            map.put("protection_policy", this.protectionPolicy == null ? new VMPP("OpaqueRef:NULL") : this.protectionPolicy);
+            map.put("is_snapshot_from_vmpp", this.isSnapshotFromVmpp == null ? false : this.isSnapshotFromVmpp);
+            map.put("appliance", this.appliance == null ? new VMAppliance("OpaqueRef:NULL") : this.appliance);
+            map.put("start_delay", this.startDelay == null ? 0 : this.startDelay);
+            map.put("shutdown_delay", this.shutdownDelay == null ? 0 : this.shutdownDelay);
+            map.put("order", this.order == null ? 0 : this.order);
+            map.put("VGPUs", this.VGPUs == null ? new LinkedHashSet<VGPU>() : this.VGPUs);
+            map.put("attached_PCIs", this.attachedPCIs == null ? new LinkedHashSet<PCI>() : this.attachedPCIs);
+            map.put("suspend_SR", this.suspendSR == null ? new SR("OpaqueRef:NULL") : this.suspendSR);
+            map.put("version", this.version == null ? 0 : this.version);
+            map.put("generation_id", this.generationId == null ? "" : this.generationId);
+            return map;
+        }
+
+        /**
+         * Unique identifier/object reference
+         */
+        public String uuid;
+        /**
+         * list of the operations allowed in this state. This list is advisory only and the server state may have changed by the time this field is read by a client.
+         */
+        public Set<Types.VmOperations> allowedOperations;
+        /**
+         * links each of the running tasks using this object (by reference) to a current_operation enum which describes the nature of the task.
+         */
+        public Map<String, Types.VmOperations> currentOperations;
+        /**
+         * Current power state of the machine
+         */
+        public Types.VmPowerState powerState;
+        /**
+         * a human-readable name
+         */
+        public String nameLabel;
+        /**
+         * a notes field containing human-readable description
+         */
+        public String nameDescription;
+        /**
+         * a user version number for this machine
+         */
+        public Long userVersion;
+        /**
+         * true if this is a template. Template VMs can never be started, they are used only for cloning other VMs
+         */
+        public Boolean isATemplate;
+        /**
+         * The VDI that a suspend image is stored on. (Only has meaning if VM is currently suspended)
+         */
+        public VDI suspendVDI;
+        /**
+         * the host the VM is currently resident on
+         */
+        public Host residentOn;
+        /**
+         * a host which the VM has some affinity for (or NULL). This is used as a hint to the start call when it decides where to run the VM. Implementations are free to ignore this field.
+         */
+        public Host affinity;
+        /**
+         * Virtualization memory overhead (bytes).
+         */
+        public Long memoryOverhead;
+        /**
+         * Dynamically-set memory target (bytes). The value of this field indicates the current target for memory available to this VM.
+         */
+        public Long memoryTarget;
+        /**
+         * Statically-set (i.e. absolute) maximum (bytes). The value of this field at VM start time acts as a hard limit of the amount of memory a guest can use. New values only take effect on reboot.
+         */
+        public Long memoryStaticMax;
+        /**
+         * Dynamic maximum (bytes)
+         */
+        public Long memoryDynamicMax;
+        /**
+         * Dynamic minimum (bytes)
+         */
+        public Long memoryDynamicMin;
+        /**
+         * Statically-set (i.e. absolute) mininum (bytes). The value of this field indicates the least amount of memory this VM can boot with without crashing.
+         */
+        public Long memoryStaticMin;
+        /**
+         * configuration parameters for the selected VCPU policy
+         */
+        public Map<String, String> VCPUsParams;
+        /**
+         * Max number of VCPUs
+         */
+        public Long VCPUsMax;
+        /**
+         * Boot number of VCPUs
+         */
+        public Long VCPUsAtStartup;
+        /**
+         * action to take after the guest has shutdown itself
+         */
+        public Types.OnNormalExit actionsAfterShutdown;
+        /**
+         * action to take after the guest has rebooted itself
+         */
+        public Types.OnNormalExit actionsAfterReboot;
+        /**
+         * action to take if the guest crashes
+         */
+        public Types.OnCrashBehaviour actionsAfterCrash;
+        /**
+         * virtual console devices
+         */
+        public Set<Console> consoles;
+        /**
+         * virtual network interfaces
+         */
+        public Set<VIF> VIFs;
+        /**
+         * virtual block devices
+         */
+        public Set<VBD> VBDs;
+        /**
+         * crash dumps associated with this VM
+         */
+        public Set<Crashdump> crashDumps;
+        /**
+         * virtual TPMs
+         */
+        public Set<VTPM> VTPMs;
+        /**
+         * name of or path to bootloader
+         */
+        public String PVBootloader;
+        /**
+         * path to the kernel
+         */
+        public String PVKernel;
+        /**
+         * path to the initrd
+         */
+        public String PVRamdisk;
+        /**
+         * kernel command-line arguments
+         */
+        public String PVArgs;
+        /**
+         * miscellaneous arguments for the bootloader
+         */
+        public String PVBootloaderArgs;
+        /**
+         * to make Zurich guests boot
+         */
+        public String PVLegacyArgs;
+        /**
+         * HVM boot policy
+         */
+        public String HVMBootPolicy;
+        /**
+         * HVM boot params
+         */
+        public Map<String, String> HVMBootParams;
+        /**
+         * multiplier applied to the amount of shadow that will be made available to the guest
+         */
+        public Double HVMShadowMultiplier;
+        /**
+         * platform-specific configuration
+         */
+        public Map<String, String> platform;
+        /**
+         * PCI bus path for pass-through devices
+         */
+        public String PCIBus;
+        /**
+         * additional configuration
+         */
+        public Map<String, String> otherConfig;
+        /**
+         * domain ID (if available, -1 otherwise)
+         */
+        public Long domid;
+        /**
+         * Domain architecture (if available, null string otherwise)
+         */
+        public String domarch;
+        /**
+         * describes the CPU flags on which the VM was last booted
+         */
+        public Map<String, String> lastBootCPUFlags;
+        /**
+         * true if this is a control domain (domain 0 or a driver domain)
+         */
+        public Boolean isControlDomain;
+        /**
+         * metrics associated with this VM
+         */
+        public VMMetrics metrics;
+        /**
+         * metrics associated with the running guest
+         */
+        public VMGuestMetrics guestMetrics;
+        /**
+         * marshalled value containing VM record at time of last boot, updated dynamically to reflect the runtime state of the domain
+         */
+        public String lastBootedRecord;
+        /**
+         * An XML specification of recommended values and ranges for properties of this VM
+         */
+        public String recommendations;
+        /**
+         * data to be inserted into the xenstore tree (/local/domain/<domid>/vm-data) after the VM is created.
+         */
+        public Map<String, String> xenstoreData;
+        /**
+         * if true then the system will attempt to keep the VM running as much as possible.
+         */
+        public Boolean haAlwaysRun;
+        /**
+         * has possible values: "best-effort" meaning "try to restart this VM if possible but don't consider the Pool to be overcommitted if this is not possible"; "restart" meaning "this VM should be restarted"; "" meaning "do not try to restart this VM"
+         */
+        public String haRestartPriority;
+        /**
+         * true if this is a snapshot. Snapshotted VMs can never be started, they are used only for cloning other VMs
+         */
+        public Boolean isASnapshot;
+        /**
+         * Ref pointing to the VM this snapshot is of.
+         */
+        public VM snapshotOf;
+        /**
+         * List pointing to all the VM snapshots.
+         */
+        public Set<VM> snapshots;
+        /**
+         * Date/time when this snapshot was created.
+         */
+        public Date snapshotTime;
+        /**
+         * Transportable ID of the snapshot VM
+         */
+        public String transportableSnapshotId;
+        /**
+         * Binary blobs associated with this VM
+         */
+        public Map<String, Blob> blobs;
+        /**
+         * user-specified tags for categorization purposes
+         */
+        public Set<String> tags;
+        /**
+         * List of operations which have been explicitly blocked and an error code
+         */
+        public Map<Types.VmOperations, String> blockedOperations;
+        /**
+         * Human-readable information concerning this snapshot
+         */
+        public Map<String, String> snapshotInfo;
+        /**
+         * Encoded information about the VM's metadata this is a snapshot of
+         */
+        public String snapshotMetadata;
+        /**
+         * Ref pointing to the parent of this VM
+         */
+        public VM parent;
+        /**
+         * List pointing to all the children of this VM
+         */
+        public Set<VM> children;
+        /**
+         * BIOS strings
+         */
+        public Map<String, String> biosStrings;
+        /**
+         * Ref pointing to a protection policy for this VM
+         */
+        public VMPP protectionPolicy;
+        /**
+         * true if this snapshot was created by the protection policy
+         */
+        public Boolean isSnapshotFromVmpp;
+        /**
+         * the appliance to which this VM belongs
+         */
+        public VMAppliance appliance;
+        /**
+         * The delay to wait before proceeding to the next order in the startup sequence (seconds)
+         */
+        public Long startDelay;
+        /**
+         * The delay to wait before proceeding to the next order in the shutdown sequence (seconds)
+         */
+        public Long shutdownDelay;
+        /**
+         * The point in the startup or shutdown sequence at which this VM will be started
+         */
+        public Long order;
+        /**
+         * Virtual GPUs
+         */
+        public Set<VGPU> VGPUs;
+        /**
+         * Currently passed-through PCI devices
+         */
+        public Set<PCI> attachedPCIs;
+        /**
+         * The SR on which a suspend image is stored
+         */
+        public SR suspendSR;
+        /**
+         * The number of times this VM has been recovered
+         */
+        public Long version;
+        /**
+         * Generation ID of the VM
+         */
+        public String generationId;
+    }
+
+    /**
+     * Get a record containing the current state of the given VM.
+     *
+     * @return all fields from the object
+     */
+    public VM.Record getRecord(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_record";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVMRecord(result);
+    }
+
+    /**
+     * Get a reference to the VM instance with the specified UUID.
+     *
+     * @param uuid UUID of object to return
+     * @return reference to the object
+     */
+    public static VM getByUuid(Connection c, String uuid) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_by_uuid";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(uuid)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVM(result);
+    }
+
+    /**
+     * Create a new VM instance, and return its handle.
+     *
+     * @param record All constructor arguments
+     * @return Task
+     */
+    public static Task createAsync(Connection c, VM.Record record) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "Async.VM.create";
+        String session = c.getSessionReference();
+        Map<String, Object> record_map = record.toMap();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(record_map)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+        return Types.toTask(result);
+    }
+
+    /**
+     * Create a new VM instance, and return its handle.
+     *
+     * @param record All constructor arguments
+     * @return reference to the newly created object
+     */
+    public static VM create(Connection c, VM.Record record) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.create";
+        String session = c.getSessionReference();
+        Map<String, Object> record_map = record.toMap();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(record_map)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVM(result);
+    }
+
+    /**
+     * Destroy the specified VM.  The VM is completely removed from the system.  This function can only be called when the VM is in the Halted State.
+     *
+     * @return Task
+     */
+    public Task destroyAsync(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "Async.VM.destroy";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+        return Types.toTask(result);
+    }
+
+    /**
+     * Destroy the specified VM.  The VM is completely removed from the system.  This function can only be called when the VM is in the Halted State.
+     *
+     */
+    public void destroy(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.destroy";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Get all the VM instances with the given label.
+     *
+     * @param label label of object to return
+     * @return references to objects with matching names
+     */
+    public static Set<VM> getByNameLabel(Connection c, String label) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_by_name_label";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(label)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVM(result);
+    }
+
+    /**
+     * Get the uuid field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getUuid(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_uuid";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the allowed_operations field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<Types.VmOperations> getAllowedOperations(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_allowed_operations";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVmOperations(result);
+    }
+
+    /**
+     * Get the current_operations field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, Types.VmOperations> getCurrentOperations(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_current_operations";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringVmOperations(result);
+    }
+
+    /**
+     * Get the power_state field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Types.VmPowerState getPowerState(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_power_state";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVmPowerState(result);
+    }
+
+    /**
+     * Get the name/label field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getNameLabel(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_name_label";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the name/description field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getNameDescription(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_name_description";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the user_version field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getUserVersion(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_user_version";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the is_a_template field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Boolean getIsATemplate(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_is_a_template";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toBoolean(result);
+    }
+
+    /**
+     * Get the suspend_VDI field of the given VM.
+     *
+     * @return value of the field
+     */
+    public VDI getSuspendVDI(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_suspend_VDI";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVDI(result);
+    }
+
+    /**
+     * Get the resident_on field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Host getResidentOn(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_resident_on";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toHost(result);
+    }
+
+    /**
+     * Get the affinity field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Host getAffinity(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_affinity";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toHost(result);
+    }
+
+    /**
+     * Get the memory/overhead field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getMemoryOverhead(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_memory_overhead";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the memory/target field of the given VM.
+     * @deprecated
+     *
+     * @return value of the field
+     */
+   @Deprecated public Long getMemoryTarget(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_memory_target";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the memory/static_max field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getMemoryStaticMax(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_memory_static_max";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the memory/dynamic_max field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getMemoryDynamicMax(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_memory_dynamic_max";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the memory/dynamic_min field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getMemoryDynamicMin(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_memory_dynamic_min";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the memory/static_min field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getMemoryStaticMin(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_memory_static_min";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the VCPUs/params field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getVCPUsParams(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_VCPUs_params";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the VCPUs/max field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getVCPUsMax(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_VCPUs_max";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the VCPUs/at_startup field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getVCPUsAtStartup(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_VCPUs_at_startup";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the actions/after_shutdown field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Types.OnNormalExit getActionsAfterShutdown(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_actions_after_shutdown";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toOnNormalExit(result);
+    }
+
+    /**
+     * Get the actions/after_reboot field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Types.OnNormalExit getActionsAfterReboot(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_actions_after_reboot";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toOnNormalExit(result);
+    }
+
+    /**
+     * Get the actions/after_crash field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Types.OnCrashBehaviour getActionsAfterCrash(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_actions_after_crash";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toOnCrashBehaviour(result);
+    }
+
+    /**
+     * Get the consoles field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<Console> getConsoles(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_consoles";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfConsole(result);
+    }
+
+    /**
+     * Get the VIFs field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<VIF> getVIFs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_VIFs";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVIF(result);
+    }
+
+    /**
+     * Get the VBDs field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<VBD> getVBDs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_VBDs";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVBD(result);
+    }
+
+    /**
+     * Get the crash_dumps field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<Crashdump> getCrashDumps(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_crash_dumps";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfCrashdump(result);
+    }
+
+    /**
+     * Get the VTPMs field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<VTPM> getVTPMs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_VTPMs";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVTPM(result);
+    }
+
+    /**
+     * Get the PV/bootloader field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getPVBootloader(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_PV_bootloader";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the PV/kernel field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getPVKernel(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_PV_kernel";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the PV/ramdisk field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getPVRamdisk(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_PV_ramdisk";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the PV/args field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getPVArgs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_PV_args";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the PV/bootloader_args field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getPVBootloaderArgs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_PV_bootloader_args";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the PV/legacy_args field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getPVLegacyArgs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_PV_legacy_args";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the HVM/boot_policy field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getHVMBootPolicy(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_HVM_boot_policy";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the HVM/boot_params field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getHVMBootParams(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_HVM_boot_params";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the HVM/shadow_multiplier field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Double getHVMShadowMultiplier(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_HVM_shadow_multiplier";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toDouble(result);
+    }
+
+    /**
+     * Get the platform field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getPlatform(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_platform";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the PCI_bus field of the given VM.
+     * @deprecated
+     *
+     * @return value of the field
+     */
+   @Deprecated public String getPCIBus(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_PCI_bus";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the other_config field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getOtherConfig(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_other_config";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the domid field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getDomid(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_domid";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the domarch field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getDomarch(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_domarch";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the last_boot_CPU_flags field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getLastBootCPUFlags(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_last_boot_CPU_flags";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the is_control_domain field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Boolean getIsControlDomain(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_is_control_domain";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toBoolean(result);
+    }
+
+    /**
+     * Get the metrics field of the given VM.
+     *
+     * @return value of the field
+     */
+    public VMMetrics getMetrics(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_metrics";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVMMetrics(result);
+    }
+
+    /**
+     * Get the guest_metrics field of the given VM.
+     *
+     * @return value of the field
+     */
+    public VMGuestMetrics getGuestMetrics(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_guest_metrics";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVMGuestMetrics(result);
+    }
+
+    /**
+     * Get the last_booted_record field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getLastBootedRecord(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_last_booted_record";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the recommendations field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getRecommendations(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_recommendations";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the xenstore_data field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getXenstoreData(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_xenstore_data";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the ha_always_run field of the given VM.
+     * @deprecated
+     *
+     * @return value of the field
+     */
+   @Deprecated public Boolean getHaAlwaysRun(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_ha_always_run";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toBoolean(result);
+    }
+
+    /**
+     * Get the ha_restart_priority field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getHaRestartPriority(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_ha_restart_priority";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the is_a_snapshot field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Boolean getIsASnapshot(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_is_a_snapshot";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toBoolean(result);
+    }
+
+    /**
+     * Get the snapshot_of field of the given VM.
+     *
+     * @return value of the field
+     */
+    public VM getSnapshotOf(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_snapshot_of";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVM(result);
+    }
+
+    /**
+     * Get the snapshots field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<VM> getSnapshots(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_snapshots";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVM(result);
+    }
+
+    /**
+     * Get the snapshot_time field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Date getSnapshotTime(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_snapshot_time";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toDate(result);
+    }
+
+    /**
+     * Get the transportable_snapshot_id field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getTransportableSnapshotId(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_transportable_snapshot_id";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the blobs field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, Blob> getBlobs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_blobs";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringBlob(result);
+    }
+
+    /**
+     * Get the tags field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<String> getTags(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_tags";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfString(result);
+    }
+
+    /**
+     * Get the blocked_operations field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<Types.VmOperations, String> getBlockedOperations(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_blocked_operations";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfVmOperationsString(result);
+    }
+
+    /**
+     * Get the snapshot_info field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getSnapshotInfo(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_snapshot_info";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the snapshot_metadata field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getSnapshotMetadata(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_snapshot_metadata";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Get the parent field of the given VM.
+     *
+     * @return value of the field
+     */
+    public VM getParent(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_parent";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVM(result);
+    }
+
+    /**
+     * Get the children field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<VM> getChildren(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_children";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVM(result);
+    }
+
+    /**
+     * Get the bios_strings field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Map<String, String> getBiosStrings(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_bios_strings";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toMapOfStringString(result);
+    }
+
+    /**
+     * Get the protection_policy field of the given VM.
+     * @deprecated
+     *
+     * @return value of the field
+     */
+   @Deprecated public VMPP getProtectionPolicy(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_protection_policy";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVMPP(result);
+    }
+
+    /**
+     * Get the is_snapshot_from_vmpp field of the given VM.
+     * @deprecated
+     *
+     * @return value of the field
+     */
+   @Deprecated public Boolean getIsSnapshotFromVmpp(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_is_snapshot_from_vmpp";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toBoolean(result);
+    }
+
+    /**
+     * Get the appliance field of the given VM.
+     *
+     * @return value of the field
+     */
+    public VMAppliance getAppliance(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_appliance";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toVMAppliance(result);
+    }
+
+    /**
+     * Get the start_delay field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getStartDelay(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_start_delay";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the shutdown_delay field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getShutdownDelay(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_shutdown_delay";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the order field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getOrder(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_order";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the VGPUs field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<VGPU> getVGPUs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_VGPUs";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfVGPU(result);
+    }
+
+    /**
+     * Get the attached_PCIs field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Set<PCI> getAttachedPCIs(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_attached_PCIs";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSetOfPCI(result);
+    }
+
+    /**
+     * Get the suspend_SR field of the given VM.
+     *
+     * @return value of the field
+     */
+    public SR getSuspendSR(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_suspend_SR";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toSR(result);
+    }
+
+    /**
+     * Get the version field of the given VM.
+     *
+     * @return value of the field
+     */
+    public Long getVersion(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_version";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toLong(result);
+    }
+
+    /**
+     * Get the generation_id field of the given VM.
+     *
+     * @return value of the field
+     */
+    public String getGenerationId(Connection c) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.get_generation_id";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)};
+        Map response = c.dispatch(method_call, method_params);
+        Object result = response.get("Value");
+            return Types.toString(result);
+    }
+
+    /**
+     * Set the name/label field of the given VM.
+     *
+     * @param label New value to set
+     */
+    public void setNameLabel(Connection c, String label) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_name_label";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(label)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the name/description field of the given VM.
+     *
+     * @param description New value to set
+     */
+    public void setNameDescription(Connection c, String description) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_name_description";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(description)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the user_version field of the given VM.
+     *
+     * @param userVersion New value to set
+     */
+    public void setUserVersion(Connection c, Long userVersion) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_user_version";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(userVersion)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the is_a_template field of the given VM.
+     *
+     * @param isATemplate New value to set
+     */
+    public void setIsATemplate(Connection c, Boolean isATemplate) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_is_a_template";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(isATemplate)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the affinity field of the given VM.
+     *
+     * @param affinity New value to set
+     */
+    public void setAffinity(Connection c, Host affinity) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_affinity";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(affinity)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the VCPUs/params field of the given VM.
+     *
+     * @param params New value to set
+     */
+    public void setVCPUsParams(Connection c, Map<String, String> params) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_VCPUs_params";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(params)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Add the given key-value pair to the VCPUs/params field of the given VM.
+     *
+     * @param key Key to add
+     * @param value Value to add
+     */
+    public void addToVCPUsParams(Connection c, String key, String value) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.add_to_VCPUs_params";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(key), Marshalling.toXMLRPC(value)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Remove the given key and its corresponding value from the VCPUs/params field of the given VM.  If the key is not in that Map, then do nothing.
+     *
+     * @param key Key to remove
+     */
+    public void removeFromVCPUsParams(Connection c, String key) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.remove_from_VCPUs_params";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(key)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the actions/after_shutdown field of the given VM.
+     *
+     * @param afterShutdown New value to set
+     */
+    public void setActionsAfterShutdown(Connection c, Types.OnNormalExit afterShutdown) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_actions_after_shutdown";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(afterShutdown)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the actions/after_reboot field of the given VM.
+     *
+     * @param afterReboot New value to set
+     */
+    public void setActionsAfterReboot(Connection c, Types.OnNormalExit afterReboot) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_actions_after_reboot";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(afterReboot)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the actions/after_crash field of the given VM.
+     *
+     * @param afterCrash New value to set
+     */
+    public void setActionsAfterCrash(Connection c, Types.OnCrashBehaviour afterCrash) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_actions_after_crash";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(afterCrash)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the PV/bootloader field of the given VM.
+     *
+     * @param bootloader New value to set
+     */
+    public void setPVBootloader(Connection c, String bootloader) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_PV_bootloader";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(bootloader)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the PV/kernel field of the given VM.
+     *
+     * @param kernel New value to set
+     */
+    public void setPVKernel(Connection c, String kernel) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_PV_kernel";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(kernel)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the PV/ramdisk field of the given VM.
+     *
+     * @param ramdisk New value to set
+     */
+    public void setPVRamdisk(Connection c, String ramdisk) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_PV_ramdisk";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(ramdisk)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the PV/args field of the given VM.
+     *
+     * @param args New value to set
+     */
+    public void setPVArgs(Connection c, String args) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_PV_args";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(args)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the PV/bootloader_args field of the given VM.
+     *
+     * @param bootloaderArgs New value to set
+     */
+    public void setPVBootloaderArgs(Connection c, String bootloaderArgs) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_PV_bootloader_args";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(bootloaderArgs)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the PV/legacy_args field of the given VM.
+     *
+     * @param legacyArgs New value to set
+     */
+    public void setPVLegacyArgs(Connection c, String legacyArgs) throws
+       BadServerResponse,
+       XenAPIException,
+       XmlRpcException {
+        String method_call = "VM.set_PV_legacy_args";
+        String session = c.getSessionReference();
+        Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(legacyArgs)};
+        Map response = c.dispatch(method_call, method_params);
+        return;
+    }
+
+    /**
+     * Set the HVM/boot_policy field of the given VM.
+     *
+     * @param bootPolicy New value to set
+    

<TRUNCATED>

Mime
View raw message