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 72A1710F58 for ; Tue, 8 Apr 2014 07:04:04 +0000 (UTC) Received: (qmail 63076 invoked by uid 500); 8 Apr 2014 07:03:44 -0000 Delivered-To: apmail-cloudstack-commits-archive@cloudstack.apache.org Received: (qmail 63012 invoked by uid 500); 8 Apr 2014 07:03:43 -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 62985 invoked by uid 99); 8 Apr 2014 07:03:42 -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:42 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id 675D194DABB; 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:43 -0000 Message-Id: In-Reply-To: <9c267dd5e063430caeb2512da97b015e@git.apache.org> References: <9c267dd5e063430caeb2512da97b015e@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [02/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/VMAppliance.java ---------------------------------------------------------------------- diff --git a/deps/XenServerJava/src/com/xensource/xenapi/VMAppliance.java b/deps/XenServerJava/src/com/xensource/xenapi/VMAppliance.java new file mode 100644 index 0000000..a0eb0d6 --- /dev/null +++ b/deps/XenServerJava/src/com/xensource/xenapi/VMAppliance.java @@ -0,0 +1,655 @@ +/* + * 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; + +/** + * VM appliance + * + * @author Citrix Systems, Inc. + */ +public class VMAppliance extends XenAPIObject { + + /** + * The XenAPI reference (OpaqueRef) to this object. + */ + protected final String ref; + + /** + * For internal use only. + */ + VMAppliance(String ref) { + this.ref = ref; + } + + /** + * @return The XenAPI reference (OpaqueRef) to this object. + */ + public String toWireString() { + return this.ref; + } + + /** + * If obj is a VMAppliance, compares XenAPI references for equality. + */ + @Override + public boolean equals(Object obj) + { + if (obj != null && obj instanceof VMAppliance) + { + VMAppliance other = (VMAppliance) obj; + return other.ref.equals(this.ref); + } else + { + return false; + } + } + + @Override + public int hashCode() + { + return ref.hashCode(); + } + + /** + * Represents all the fields in a VMAppliance + */ + 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", "nameLabel", this.nameLabel); + print.printf("%1$20s: %2$s\n", "nameDescription", this.nameDescription); + 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", "VMs", this.VMs); + return writer.toString(); + } + + /** + * Convert a VM_appliance.Record to a Map + */ + public Map toMap() { + Map map = new HashMap(); + map.put("uuid", this.uuid == null ? "" : this.uuid); + map.put("name_label", this.nameLabel == null ? "" : this.nameLabel); + map.put("name_description", this.nameDescription == null ? "" : this.nameDescription); + map.put("allowed_operations", this.allowedOperations == null ? new LinkedHashSet() : this.allowedOperations); + map.put("current_operations", this.currentOperations == null ? new HashMap() : this.currentOperations); + map.put("VMs", this.VMs == null ? new LinkedHashSet() : this.VMs); + return map; + } + + /** + * Unique identifier/object reference + */ + public String uuid; + /** + * a human-readable name + */ + public String nameLabel; + /** + * a notes field containing human-readable description + */ + public String nameDescription; + /** + * 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; + /** + * all VMs in this appliance + */ + public Set VMs; + } + + /** + * Get a record containing the current state of the given VM_appliance. + * + * @return all fields from the object + */ + public VMAppliance.Record getRecord(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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.toVMApplianceRecord(result); + } + + /** + * Get a reference to the VM_appliance instance with the specified UUID. + * + * @param uuid UUID of object to return + * @return reference to the object + */ + public static VMAppliance getByUuid(Connection c, String uuid) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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.toVMAppliance(result); + } + + /** + * Create a new VM_appliance instance, and return its handle. + * + * @param record All constructor arguments + * @return Task + */ + public static Task createAsync(Connection c, VMAppliance.Record record) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "Async.VM_appliance.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_appliance instance, and return its handle. + * + * @param record All constructor arguments + * @return reference to the newly created object + */ + public static VMAppliance create(Connection c, VMAppliance.Record record) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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.toVMAppliance(result); + } + + /** + * Destroy the specified VM_appliance instance. + * + * @return Task + */ + public Task destroyAsync(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "Async.VM_appliance.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_appliance instance. + * + */ + public void destroy(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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_appliance 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_appliance.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.toSetOfVMAppliance(result); + } + + /** + * Get the uuid field of the given VM_appliance. + * + * @return value of the field + */ + public String getUuid(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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 name/label field of the given VM_appliance. + * + * @return value of the field + */ + public String getNameLabel(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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_appliance. + * + * @return value of the field + */ + public String getNameDescription(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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 allowed_operations field of the given VM_appliance. + * + * @return value of the field + */ + public Set getAllowedOperations(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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.toSetOfVmApplianceOperation(result); + } + + /** + * Get the current_operations field of the given VM_appliance. + * + * @return value of the field + */ + public Map getCurrentOperations(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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.toMapOfStringVmApplianceOperation(result); + } + + /** + * Get the VMs field of the given VM_appliance. + * + * @return value of the field + */ + public Set getVMs(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.get_VMs"; + 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); + } + + /** + * Set the name/label field of the given VM_appliance. + * + * @param label New value to set + */ + public void setNameLabel(Connection c, String label) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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_appliance. + * + * @param description New value to set + */ + public void setNameDescription(Connection c, String description) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.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; + } + + /** + * Start all VMs in the appliance + * + * @param paused Instantiate all VMs belonging to this appliance in paused state if set to true. + * @return Task + */ + public Task startAsync(Connection c, Boolean paused) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "Async.VM_appliance.start"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(paused)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toTask(result); + } + + /** + * Start all VMs in the appliance + * + * @param paused Instantiate all VMs belonging to this appliance in paused state if set to true. + */ + public void start(Connection c, Boolean paused) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "VM_appliance.start"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(paused)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Perform a clean shutdown of all the VMs in the appliance + * + * @return Task + */ + public Task cleanShutdownAsync(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "Async.VM_appliance.clean_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.toTask(result); + } + + /** + * Perform a clean shutdown of all the VMs in the appliance + * + */ + public void cleanShutdown(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "VM_appliance.clean_shutdown"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Perform a hard shutdown of all the VMs in the appliance + * + * @return Task + */ + public Task hardShutdownAsync(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "Async.VM_appliance.hard_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.toTask(result); + } + + /** + * Perform a hard shutdown of all the VMs in the appliance + * + */ + public void hardShutdown(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "VM_appliance.hard_shutdown"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * For each VM in the appliance, try to shut it down cleanly. If this fails, perform a hard shutdown of the VM. + * + * @return Task + */ + public Task shutdownAsync(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "Async.VM_appliance.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.toTask(result); + } + + /** + * For each VM in the appliance, try to shut it down cleanly. If this fails, perform a hard shutdown of the VM. + * + */ + public void shutdown(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.OperationPartiallyFailed { + String method_call = "VM_appliance.shutdown"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Assert whether all SRs required to recover this VM appliance are available. + * + * @param sessionTo The session to which the VM appliance is to be recovered. + * @return Task + */ + public Task assertCanBeRecoveredAsync(Connection c, Session sessionTo) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.VmRequiresSr { + String method_call = "Async.VM_appliance.assert_can_be_recovered"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(sessionTo)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toTask(result); + } + + /** + * Assert whether all SRs required to recover this VM appliance are available. + * + * @param sessionTo The session to which the VM appliance is to be recovered. + */ + public void assertCanBeRecovered(Connection c, Session sessionTo) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.VmRequiresSr { + String method_call = "VM_appliance.assert_can_be_recovered"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(sessionTo)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Recover the VM appliance + * + * @param sessionTo The session to which the VM appliance is to be recovered. + * @param force Whether the VMs should replace newer versions of themselves. + * @return Task + */ + public Task recoverAsync(Connection c, Session sessionTo, Boolean force) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.VmRequiresSr { + String method_call = "Async.VM_appliance.recover"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(sessionTo), Marshalling.toXMLRPC(force)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toTask(result); + } + + /** + * Recover the VM appliance + * + * @param sessionTo The session to which the VM appliance is to be recovered. + * @param force Whether the VMs should replace newer versions of themselves. + */ + public void recover(Connection c, Session sessionTo, Boolean force) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.VmRequiresSr { + String method_call = "VM_appliance.recover"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(sessionTo), Marshalling.toXMLRPC(force)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Return a list of all the VM_appliances known to the system. + * + * @return references to all objects + */ + public static Set getAll(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.get_all"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toSetOfVMAppliance(result); + } + + /** + * Return a map of VM_appliance references to VM_appliance records for all VM_appliances known to the system. + * + * @return records of all objects + */ + public static Map getAllRecords(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_appliance.get_all_records"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toMapOfVMApplianceVMApplianceRecord(result); + } + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/cloudstack/blob/ec102ec9/deps/XenServerJava/src/com/xensource/xenapi/VMGuestMetrics.java ---------------------------------------------------------------------- diff --git a/deps/XenServerJava/src/com/xensource/xenapi/VMGuestMetrics.java b/deps/XenServerJava/src/com/xensource/xenapi/VMGuestMetrics.java new file mode 100644 index 0000000..024f6c4 --- /dev/null +++ b/deps/XenServerJava/src/com/xensource/xenapi/VMGuestMetrics.java @@ -0,0 +1,487 @@ +/* + * 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; + +/** + * The metrics reported by the guest (as opposed to inferred from outside) + * + * @author Citrix Systems, Inc. + */ +public class VMGuestMetrics extends XenAPIObject { + + /** + * The XenAPI reference (OpaqueRef) to this object. + */ + protected final String ref; + + /** + * For internal use only. + */ + VMGuestMetrics(String ref) { + this.ref = ref; + } + + /** + * @return The XenAPI reference (OpaqueRef) to this object. + */ + public String toWireString() { + return this.ref; + } + + /** + * If obj is a VMGuestMetrics, compares XenAPI references for equality. + */ + @Override + public boolean equals(Object obj) + { + if (obj != null && obj instanceof VMGuestMetrics) + { + VMGuestMetrics other = (VMGuestMetrics) obj; + return other.ref.equals(this.ref); + } else + { + return false; + } + } + + @Override + public int hashCode() + { + return ref.hashCode(); + } + + /** + * Represents all the fields in a VMGuestMetrics + */ + 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", "osVersion", this.osVersion); + print.printf("%1$20s: %2$s\n", "PVDriversVersion", this.PVDriversVersion); + print.printf("%1$20s: %2$s\n", "PVDriversUpToDate", this.PVDriversUpToDate); + print.printf("%1$20s: %2$s\n", "memory", this.memory); + print.printf("%1$20s: %2$s\n", "disks", this.disks); + print.printf("%1$20s: %2$s\n", "networks", this.networks); + print.printf("%1$20s: %2$s\n", "other", this.other); + print.printf("%1$20s: %2$s\n", "lastUpdated", this.lastUpdated); + print.printf("%1$20s: %2$s\n", "otherConfig", this.otherConfig); + print.printf("%1$20s: %2$s\n", "live", this.live); + return writer.toString(); + } + + /** + * Convert a VM_guest_metrics.Record to a Map + */ + public Map toMap() { + Map map = new HashMap(); + map.put("uuid", this.uuid == null ? "" : this.uuid); + map.put("os_version", this.osVersion == null ? new HashMap() : this.osVersion); + map.put("PV_drivers_version", this.PVDriversVersion == null ? new HashMap() : this.PVDriversVersion); + map.put("PV_drivers_up_to_date", this.PVDriversUpToDate == null ? false : this.PVDriversUpToDate); + map.put("memory", this.memory == null ? new HashMap() : this.memory); + map.put("disks", this.disks == null ? new HashMap() : this.disks); + map.put("networks", this.networks == null ? new HashMap() : this.networks); + map.put("other", this.other == null ? new HashMap() : this.other); + map.put("last_updated", this.lastUpdated == null ? new Date(0) : this.lastUpdated); + map.put("other_config", this.otherConfig == null ? new HashMap() : this.otherConfig); + map.put("live", this.live == null ? false : this.live); + return map; + } + + /** + * Unique identifier/object reference + */ + public String uuid; + /** + * version of the OS + */ + public Map osVersion; + /** + * version of the PV drivers + */ + public Map PVDriversVersion; + /** + * true if the PV drivers appear to be up to date + */ + public Boolean PVDriversUpToDate; + /** + * free/used/total memory + */ + public Map memory; + /** + * disk configuration/free space + */ + public Map disks; + /** + * network configuration + */ + public Map networks; + /** + * anything else + */ + public Map other; + /** + * Time at which this information was last updated + */ + public Date lastUpdated; + /** + * additional configuration + */ + public Map otherConfig; + /** + * True if the guest is sending heartbeat messages via the guest agent + */ + public Boolean live; + } + + /** + * Get a record containing the current state of the given VM_guest_metrics. + * + * @return all fields from the object + */ + public VMGuestMetrics.Record getRecord(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.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.toVMGuestMetricsRecord(result); + } + + /** + * Get a reference to the VM_guest_metrics instance with the specified UUID. + * + * @param uuid UUID of object to return + * @return reference to the object + */ + public static VMGuestMetrics getByUuid(Connection c, String uuid) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.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.toVMGuestMetrics(result); + } + + /** + * Get the uuid field of the given VM_guest_metrics. + * + * @return value of the field + */ + public String getUuid(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.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 os_version field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Map getOsVersion(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_os_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.toMapOfStringString(result); + } + + /** + * Get the PV_drivers_version field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Map getPVDriversVersion(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_PV_drivers_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.toMapOfStringString(result); + } + + /** + * Get the PV_drivers_up_to_date field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Boolean getPVDriversUpToDate(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_PV_drivers_up_to_date"; + 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 memory field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Map getMemory(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_memory"; + 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 disks field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Map getDisks(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_disks"; + 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 networks field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Map getNetworks(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_networks"; + 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 other field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Map getOther(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_other"; + 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 last_updated field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Date getLastUpdated(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_last_updated"; + 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 other_config field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Map getOtherConfig(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.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 live field of the given VM_guest_metrics. + * + * @return value of the field + */ + public Boolean getLive(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_live"; + 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); + } + + /** + * Set the other_config field of the given VM_guest_metrics. + * + * @param otherConfig New value to set + */ + public void setOtherConfig(Connection c, Map otherConfig) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.set_other_config"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(otherConfig)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Add the given key-value pair to the other_config field of the given VM_guest_metrics. + * + * @param key Key to add + * @param value Value to add + */ + public void addToOtherConfig(Connection c, String key, String value) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.add_to_other_config"; + 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 other_config field of the given VM_guest_metrics. If the key is not in that Map, then do nothing. + * + * @param key Key to remove + */ + public void removeFromOtherConfig(Connection c, String key) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.remove_from_other_config"; + 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; + } + + /** + * Return a list of all the VM_guest_metrics instances known to the system. + * + * @return references to all objects + */ + public static Set getAll(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_all"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toSetOfVMGuestMetrics(result); + } + + /** + * Return a map of VM_guest_metrics references to VM_guest_metrics records for all VM_guest_metrics instances known to the system. + * + * @return records of all objects + */ + public static Map getAllRecords(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_guest_metrics.get_all_records"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toMapOfVMGuestMetricsVMGuestMetricsRecord(result); + } + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/cloudstack/blob/ec102ec9/deps/XenServerJava/src/com/xensource/xenapi/VMMetrics.java ---------------------------------------------------------------------- diff --git a/deps/XenServerJava/src/com/xensource/xenapi/VMMetrics.java b/deps/XenServerJava/src/com/xensource/xenapi/VMMetrics.java new file mode 100644 index 0000000..30f4984 --- /dev/null +++ b/deps/XenServerJava/src/com/xensource/xenapi/VMMetrics.java @@ -0,0 +1,510 @@ +/* + * 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; + +/** + * The metrics associated with a VM + * + * @author Citrix Systems, Inc. + */ +public class VMMetrics extends XenAPIObject { + + /** + * The XenAPI reference (OpaqueRef) to this object. + */ + protected final String ref; + + /** + * For internal use only. + */ + VMMetrics(String ref) { + this.ref = ref; + } + + /** + * @return The XenAPI reference (OpaqueRef) to this object. + */ + public String toWireString() { + return this.ref; + } + + /** + * If obj is a VMMetrics, compares XenAPI references for equality. + */ + @Override + public boolean equals(Object obj) + { + if (obj != null && obj instanceof VMMetrics) + { + VMMetrics other = (VMMetrics) obj; + return other.ref.equals(this.ref); + } else + { + return false; + } + } + + @Override + public int hashCode() + { + return ref.hashCode(); + } + + /** + * Represents all the fields in a VMMetrics + */ + 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", "memoryActual", this.memoryActual); + print.printf("%1$20s: %2$s\n", "VCPUsNumber", this.VCPUsNumber); + print.printf("%1$20s: %2$s\n", "VCPUsUtilisation", this.VCPUsUtilisation); + print.printf("%1$20s: %2$s\n", "VCPUsCPU", this.VCPUsCPU); + print.printf("%1$20s: %2$s\n", "VCPUsParams", this.VCPUsParams); + print.printf("%1$20s: %2$s\n", "VCPUsFlags", this.VCPUsFlags); + print.printf("%1$20s: %2$s\n", "state", this.state); + print.printf("%1$20s: %2$s\n", "startTime", this.startTime); + print.printf("%1$20s: %2$s\n", "installTime", this.installTime); + print.printf("%1$20s: %2$s\n", "lastUpdated", this.lastUpdated); + print.printf("%1$20s: %2$s\n", "otherConfig", this.otherConfig); + return writer.toString(); + } + + /** + * Convert a VM_metrics.Record to a Map + */ + public Map toMap() { + Map map = new HashMap(); + map.put("uuid", this.uuid == null ? "" : this.uuid); + map.put("memory_actual", this.memoryActual == null ? 0 : this.memoryActual); + map.put("VCPUs_number", this.VCPUsNumber == null ? 0 : this.VCPUsNumber); + map.put("VCPUs_utilisation", this.VCPUsUtilisation == null ? new HashMap() : this.VCPUsUtilisation); + map.put("VCPUs_CPU", this.VCPUsCPU == null ? new HashMap() : this.VCPUsCPU); + map.put("VCPUs_params", this.VCPUsParams == null ? new HashMap() : this.VCPUsParams); + map.put("VCPUs_flags", this.VCPUsFlags == null ? new HashMap>() : this.VCPUsFlags); + map.put("state", this.state == null ? new LinkedHashSet() : this.state); + map.put("start_time", this.startTime == null ? new Date(0) : this.startTime); + map.put("install_time", this.installTime == null ? new Date(0) : this.installTime); + map.put("last_updated", this.lastUpdated == null ? new Date(0) : this.lastUpdated); + map.put("other_config", this.otherConfig == null ? new HashMap() : this.otherConfig); + return map; + } + + /** + * Unique identifier/object reference + */ + public String uuid; + /** + * Guest's actual memory (bytes) + */ + public Long memoryActual; + /** + * Current number of VCPUs + */ + public Long VCPUsNumber; + /** + * Utilisation for all of guest's current VCPUs + */ + public Map VCPUsUtilisation; + /** + * VCPU to PCPU map + */ + public Map VCPUsCPU; + /** + * The live equivalent to VM.VCPUs_params + */ + public Map VCPUsParams; + /** + * CPU flags (blocked,online,running) + */ + public Map> VCPUsFlags; + /** + * The state of the guest, eg blocked, dying etc + */ + public Set state; + /** + * Time at which this VM was last booted + */ + public Date startTime; + /** + * Time at which the VM was installed + */ + public Date installTime; + /** + * Time at which this information was last updated + */ + public Date lastUpdated; + /** + * additional configuration + */ + public Map otherConfig; + } + + /** + * Get a record containing the current state of the given VM_metrics. + * + * @return all fields from the object + */ + public VMMetrics.Record getRecord(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.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.toVMMetricsRecord(result); + } + + /** + * Get a reference to the VM_metrics instance with the specified UUID. + * + * @param uuid UUID of object to return + * @return reference to the object + */ + public static VMMetrics getByUuid(Connection c, String uuid) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.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.toVMMetrics(result); + } + + /** + * Get the uuid field of the given VM_metrics. + * + * @return value of the field + */ + public String getUuid(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.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 memory/actual field of the given VM_metrics. + * + * @return value of the field + */ + public Long getMemoryActual(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_memory_actual"; + 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/number field of the given VM_metrics. + * + * @return value of the field + */ + public Long getVCPUsNumber(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_VCPUs_number"; + 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/utilisation field of the given VM_metrics. + * + * @return value of the field + */ + public Map getVCPUsUtilisation(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_VCPUs_utilisation"; + 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.toMapOfLongDouble(result); + } + + /** + * Get the VCPUs/CPU field of the given VM_metrics. + * + * @return value of the field + */ + public Map getVCPUsCPU(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_VCPUs_CPU"; + 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.toMapOfLongLong(result); + } + + /** + * Get the VCPUs/params field of the given VM_metrics. + * + * @return value of the field + */ + public Map getVCPUsParams(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.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/flags field of the given VM_metrics. + * + * @return value of the field + */ + public Map> getVCPUsFlags(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_VCPUs_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.toMapOfLongSetOfString(result); + } + + /** + * Get the state field of the given VM_metrics. + * + * @return value of the field + */ + public Set getState(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_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.toSetOfString(result); + } + + /** + * Get the start_time field of the given VM_metrics. + * + * @return value of the field + */ + public Date getStartTime(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_start_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 install_time field of the given VM_metrics. + * + * @return value of the field + */ + public Date getInstallTime(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_install_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 last_updated field of the given VM_metrics. + * + * @return value of the field + */ + public Date getLastUpdated(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_last_updated"; + 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 other_config field of the given VM_metrics. + * + * @return value of the field + */ + public Map getOtherConfig(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.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); + } + + /** + * Set the other_config field of the given VM_metrics. + * + * @param otherConfig New value to set + */ + public void setOtherConfig(Connection c, Map otherConfig) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.set_other_config"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref), Marshalling.toXMLRPC(otherConfig)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Add the given key-value pair to the other_config field of the given VM_metrics. + * + * @param key Key to add + * @param value Value to add + */ + public void addToOtherConfig(Connection c, String key, String value) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.add_to_other_config"; + 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 other_config field of the given VM_metrics. If the key is not in that Map, then do nothing. + * + * @param key Key to remove + */ + public void removeFromOtherConfig(Connection c, String key) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.remove_from_other_config"; + 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; + } + + /** + * Return a list of all the VM_metrics instances known to the system. + * + * @return references to all objects + */ + public static Set getAll(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_all"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toSetOfVMMetrics(result); + } + + /** + * Return a map of VM_metrics references to VM_metrics records for all VM_metrics instances known to the system. + * + * @return records of all objects + */ + public static Map getAllRecords(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "VM_metrics.get_all_records"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toMapOfVMMetricsVMMetricsRecord(result); + } + +} \ No newline at end of file