Return-Path: X-Original-To: apmail-cloudstack-commits-archive@www.apache.org Delivered-To: apmail-cloudstack-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 76CCE10F63 for ; Tue, 8 Apr 2014 07:04:05 +0000 (UTC) Received: (qmail 63220 invoked by uid 500); 8 Apr 2014 07:03:48 -0000 Delivered-To: apmail-cloudstack-commits-archive@cloudstack.apache.org Received: (qmail 63068 invoked by uid 500); 8 Apr 2014 07:03:44 -0000 Mailing-List: contact commits-help@cloudstack.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@cloudstack.apache.org Delivered-To: mailing list commits@cloudstack.apache.org Received: (qmail 63006 invoked by uid 99); 8 Apr 2014 07:03:43 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 08 Apr 2014 07:03:43 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id B5EA294DAC1; Tue, 8 Apr 2014 07:03:42 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: ahuang@apache.org To: commits@cloudstack.apache.org Date: Tue, 08 Apr 2014 07:03:44 -0000 Message-Id: <72308d99a6b94a2bb6786cac065f652c@git.apache.org> In-Reply-To: <9c267dd5e063430caeb2512da97b015e@git.apache.org> References: <9c267dd5e063430caeb2512da97b015e@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [03/19] Revert "Applied Tina's patches for removing the xapi jar" 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 toMap() { + Map map = new HashMap(); + map.put("uuid", this.uuid == null ? "" : this.uuid); + map.put("allowed_operations", this.allowedOperations == null ? new LinkedHashSet() : this.allowedOperations); + map.put("current_operations", this.currentOperations == null ? new HashMap() : 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() : 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() : this.consoles); + map.put("VIFs", this.VIFs == null ? new LinkedHashSet() : this.VIFs); + map.put("VBDs", this.VBDs == null ? new LinkedHashSet() : this.VBDs); + map.put("crash_dumps", this.crashDumps == null ? new LinkedHashSet() : this.crashDumps); + map.put("VTPMs", this.VTPMs == null ? new LinkedHashSet() : 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() : this.HVMBootParams); + map.put("HVM_shadow_multiplier", this.HVMShadowMultiplier == null ? 0.0 : this.HVMShadowMultiplier); + map.put("platform", this.platform == null ? new HashMap() : this.platform); + map.put("PCI_bus", this.PCIBus == null ? "" : this.PCIBus); + map.put("other_config", this.otherConfig == null ? new HashMap() : 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() : 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() : 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() : 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() : this.blobs); + map.put("tags", this.tags == null ? new LinkedHashSet() : this.tags); + map.put("blocked_operations", this.blockedOperations == null ? new HashMap() : this.blockedOperations); + map.put("snapshot_info", this.snapshotInfo == null ? new HashMap() : 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() : this.children); + map.put("bios_strings", this.biosStrings == null ? new HashMap() : 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() : this.VGPUs); + map.put("attached_PCIs", this.attachedPCIs == null ? new LinkedHashSet() : 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 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 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 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 consoles; + /** + * virtual network interfaces + */ + public Set VIFs; + /** + * virtual block devices + */ + public Set VBDs; + /** + * crash dumps associated with this VM + */ + public Set crashDumps; + /** + * virtual TPMs + */ + public Set 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 HVMBootParams; + /** + * multiplier applied to the amount of shadow that will be made available to the guest + */ + public Double HVMShadowMultiplier; + /** + * platform-specific configuration + */ + public Map platform; + /** + * PCI bus path for pass-through devices + */ + public String PCIBus; + /** + * additional configuration + */ + public Map 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 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//vm-data) after the VM is created. + */ + public Map 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 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 blobs; + /** + * user-specified tags for categorization purposes + */ + public Set tags; + /** + * List of operations which have been explicitly blocked and an error code + */ + public Map blockedOperations; + /** + * Human-readable information concerning this snapshot + */ + public Map 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 children; + /** + * BIOS strings + */ + public Map 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 VGPUs; + /** + * Currently passed-through PCI devices + */ + public Set 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 +