http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/7d59e669/deps/XenServerJava/src/com/xensource/xenapi/Console.java ---------------------------------------------------------------------- diff --git a/deps/XenServerJava/src/com/xensource/xenapi/Console.java b/deps/XenServerJava/src/com/xensource/xenapi/Console.java new file mode 100644 index 0000000..e73e685 --- /dev/null +++ b/deps/XenServerJava/src/com/xensource/xenapi/Console.java @@ -0,0 +1,414 @@ +/* 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 console + * + * @author Citrix Systems, Inc. + */ +public class Console extends XenAPIObject { + + /** + * The XenAPI reference to this object. + */ + protected final String ref; + + /** + * For internal use only. + */ + Console(String ref) { + this.ref = ref; + } + + public String toWireString() { + return this.ref; + } + + /** + * If obj is a Console, compares XenAPI references for equality. + */ + @Override + public boolean equals(Object obj) + { + if (obj != null && obj instanceof Console) + { + Console other = (Console) obj; + return other.ref.equals(this.ref); + } else + { + return false; + } + } + + @Override + public int hashCode() + { + return ref.hashCode(); + } + + /** + * Represents all the fields in a Console + */ + 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", "protocol", this.protocol); + print.printf("%1$20s: %2$s\n", "location", this.location); + print.printf("%1$20s: %2$s\n", "VM", this.VM); + print.printf("%1$20s: %2$s\n", "otherConfig", this.otherConfig); + return writer.toString(); + } + + /** + * Convert a console.Record to a Map + */ + public Map<String,Object> toMap() { + Map<String,Object> map = new HashMap<String,Object>(); + map.put("uuid", this.uuid == null ? "" : this.uuid); + map.put("protocol", this.protocol == null ? Types.ConsoleProtocol.UNRECOGNIZED : this.protocol); + map.put("location", this.location == null ? "" : this.location); + map.put("VM", this.VM == null ? new VM("OpaqueRef:NULL") : this.VM); + map.put("other_config", this.otherConfig == null ? new HashMap<String, String>() : this.otherConfig); + return map; + } + + /** + * Unique identifier/object reference + */ + public String uuid; + /** + * the protocol used by this console + */ + public Types.ConsoleProtocol protocol; + /** + * URI for the console service + */ + public String location; + /** + * VM to which this console is attached + */ + public VM VM; + /** + * additional configuration + */ + public Map<String, String> otherConfig; + } + + /** + * Get a record containing the current state of the given console. + * + * @return all fields from the object + */ + public Console.Record getRecord(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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.toConsoleRecord(result); + } + + /** + * Get a reference to the console instance with the specified UUID. + * + * @param uuid UUID of object to return + * @return reference to the object + */ + public static Console getByUuid(Connection c, String uuid) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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.toConsole(result); + } + + /** + * Create a new console instance, and return its handle. + * + * @param record All constructor arguments + * @return Task + */ + public static Task createAsync(Connection c, Console.Record record) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "Async.console.create"; + String session = c.getSessionReference(); + Map<String, Object> record_map = record.toMap(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(record_map)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toTask(result); + } + + /** + * Create a new console instance, and return its handle. + * + * @param record All constructor arguments + * @return reference to the newly created object + */ + public static Console create(Connection c, Console.Record record) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.create"; + String session = c.getSessionReference(); + Map<String, Object> record_map = record.toMap(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(record_map)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toConsole(result); + } + + /** + * Destroy the specified console instance. + * + * @return Task + */ + public Task destroyAsync(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "Async.console.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 console instance. + * + */ + public void destroy(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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 the uuid field of the given console. + * + * @return value of the field + */ + public String getUuid(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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 protocol field of the given console. + * + * @return value of the field + */ + public Types.ConsoleProtocol getProtocol(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.get_protocol"; + 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.toConsoleProtocol(result); + } + + /** + * Get the location field of the given console. + * + * @return value of the field + */ + public String getLocation(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.get_location"; + 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 VM field of the given console. + * + * @return value of the field + */ + public VM getVM(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.get_VM"; + 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 other_config field of the given console. + * + * @return value of the field + */ + public Map<String, String> getOtherConfig(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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 console. + * + * @param otherConfig New value to set + */ + public void setOtherConfig(Connection c, Map<String, String> otherConfig) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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 console. + * + * @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 = "console.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 console. 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 = "console.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 consoles known to the system. + * + * @return references to all objects + */ + public static Set<Console> getAll(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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.toSetOfConsole(result); + } + + /** + * Return a map of console references to console records for all consoles known to the system. + * + * @return records of all objects + */ + public static Map<Console, Console.Record> getAllRecords(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "console.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.toMapOfConsoleConsoleRecord(result); + } + +}
http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/7d59e669/deps/XenServerJava/src/com/xensource/xenapi/Crashdump.java ---------------------------------------------------------------------- diff --git a/deps/XenServerJava/src/com/xensource/xenapi/Crashdump.java b/deps/XenServerJava/src/com/xensource/xenapi/Crashdump.java new file mode 100644 index 0000000..31cf418 --- /dev/null +++ b/deps/XenServerJava/src/com/xensource/xenapi/Crashdump.java @@ -0,0 +1,353 @@ +/* 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 VM crashdump + * + * @author Citrix Systems, Inc. + */ +public class Crashdump extends XenAPIObject { + + /** + * The XenAPI reference to this object. + */ + protected final String ref; + + /** + * For internal use only. + */ + Crashdump(String ref) { + this.ref = ref; + } + + public String toWireString() { + return this.ref; + } + + /** + * If obj is a Crashdump, compares XenAPI references for equality. + */ + @Override + public boolean equals(Object obj) + { + if (obj != null && obj instanceof Crashdump) + { + Crashdump other = (Crashdump) obj; + return other.ref.equals(this.ref); + } else + { + return false; + } + } + + @Override + public int hashCode() + { + return ref.hashCode(); + } + + /** + * Represents all the fields in a Crashdump + */ + 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", "VM", this.VM); + print.printf("%1$20s: %2$s\n", "VDI", this.VDI); + print.printf("%1$20s: %2$s\n", "otherConfig", this.otherConfig); + return writer.toString(); + } + + /** + * Convert a crashdump.Record to a Map + */ + public Map<String,Object> toMap() { + Map<String,Object> map = new HashMap<String,Object>(); + map.put("uuid", this.uuid == null ? "" : this.uuid); + map.put("VM", this.VM == null ? new VM("OpaqueRef:NULL") : this.VM); + map.put("VDI", this.VDI == null ? new VDI("OpaqueRef:NULL") : this.VDI); + map.put("other_config", this.otherConfig == null ? new HashMap<String, String>() : this.otherConfig); + return map; + } + + /** + * Unique identifier/object reference + */ + public String uuid; + /** + * the virtual machine + */ + public VM VM; + /** + * the virtual disk + */ + public VDI VDI; + /** + * additional configuration + */ + public Map<String, String> otherConfig; + } + + /** + * Get a record containing the current state of the given crashdump. + * + * @return all fields from the object + */ + public Crashdump.Record getRecord(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.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.toCrashdumpRecord(result); + } + + /** + * Get a reference to the crashdump instance with the specified UUID. + * + * @param uuid UUID of object to return + * @return reference to the object + */ + public static Crashdump getByUuid(Connection c, String uuid) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.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.toCrashdump(result); + } + + /** + * Get the uuid field of the given crashdump. + * + * @return value of the field + */ + public String getUuid(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.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 VM field of the given crashdump. + * + * @return value of the field + */ + public VM getVM(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.get_VM"; + 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 VDI field of the given crashdump. + * + * @return value of the field + */ + public VDI getVDI(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.get_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 other_config field of the given crashdump. + * + * @return value of the field + */ + public Map<String, String> getOtherConfig(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.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 crashdump. + * + * @param otherConfig New value to set + */ + public void setOtherConfig(Connection c, Map<String, String> otherConfig) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.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 crashdump. + * + * @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 = "crashdump.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 crashdump. 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 = "crashdump.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; + } + + /** + * Destroy the specified crashdump + * + * @return Task + */ + public Task destroyAsync(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "Async.crashdump.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 crashdump + * + */ + public void destroy(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.destroy"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(this.ref)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Return a list of all the crashdumps known to the system. + * + * @return references to all objects + */ + public static Set<Crashdump> getAll(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.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.toSetOfCrashdump(result); + } + + /** + * Return a map of crashdump references to crashdump records for all crashdumps known to the system. + * + * @return records of all objects + */ + public static Map<Crashdump, Crashdump.Record> getAllRecords(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "crashdump.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.toMapOfCrashdumpCrashdumpRecord(result); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/7d59e669/deps/XenServerJava/src/com/xensource/xenapi/DataSource.java ---------------------------------------------------------------------- diff --git a/deps/XenServerJava/src/com/xensource/xenapi/DataSource.java b/deps/XenServerJava/src/com/xensource/xenapi/DataSource.java new file mode 100644 index 0000000..aebe39b --- /dev/null +++ b/deps/XenServerJava/src/com/xensource/xenapi/DataSource.java @@ -0,0 +1,159 @@ +/* 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; + +/** + * Data sources for logging in RRDs + * + * @author Citrix Systems, Inc. + */ +public class DataSource extends XenAPIObject { + + /** + * The XenAPI reference to this object. + */ + protected final String ref; + + /** + * For internal use only. + */ + DataSource(String ref) { + this.ref = ref; + } + + public String toWireString() { + return this.ref; + } + + /** + * If obj is a DataSource, compares XenAPI references for equality. + */ + @Override + public boolean equals(Object obj) + { + if (obj != null && obj instanceof DataSource) + { + DataSource other = (DataSource) obj; + return other.ref.equals(this.ref); + } else + { + return false; + } + } + + @Override + public int hashCode() + { + return ref.hashCode(); + } + + /** + * Represents all the fields in a DataSource + */ + 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", "nameLabel", this.nameLabel); + print.printf("%1$20s: %2$s\n", "nameDescription", this.nameDescription); + print.printf("%1$20s: %2$s\n", "enabled", this.enabled); + print.printf("%1$20s: %2$s\n", "standard", this.standard); + print.printf("%1$20s: %2$s\n", "units", this.units); + print.printf("%1$20s: %2$s\n", "min", this.min); + print.printf("%1$20s: %2$s\n", "max", this.max); + print.printf("%1$20s: %2$s\n", "value", this.value); + return writer.toString(); + } + + /** + * Convert a data_source.Record to a Map + */ + public Map<String,Object> toMap() { + Map<String,Object> map = new HashMap<String,Object>(); + map.put("name_label", this.nameLabel == null ? "" : this.nameLabel); + map.put("name_description", this.nameDescription == null ? "" : this.nameDescription); + map.put("enabled", this.enabled == null ? false : this.enabled); + map.put("standard", this.standard == null ? false : this.standard); + map.put("units", this.units == null ? "" : this.units); + map.put("min", this.min == null ? 0.0 : this.min); + map.put("max", this.max == null ? 0.0 : this.max); + map.put("value", this.value == null ? 0.0 : this.value); + return map; + } + + /** + * a human-readable name + */ + public String nameLabel; + /** + * a notes field containg human-readable description + */ + public String nameDescription; + /** + * true if the data source is being logged + */ + public Boolean enabled; + /** + * true if the data source is enabled by default. Non-default data sources cannot be disabled + */ + public Boolean standard; + /** + * the units of the value + */ + public String units; + /** + * the minimum value of the data source + */ + public Double min; + /** + * the maximum value of the data source + */ + public Double max; + /** + * current value of the data source + */ + public Double value; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/7d59e669/deps/XenServerJava/src/com/xensource/xenapi/Event.java ---------------------------------------------------------------------- diff --git a/deps/XenServerJava/src/com/xensource/xenapi/Event.java b/deps/XenServerJava/src/com/xensource/xenapi/Event.java new file mode 100644 index 0000000..36ebf45 --- /dev/null +++ b/deps/XenServerJava/src/com/xensource/xenapi/Event.java @@ -0,0 +1,258 @@ +/* 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; + +/** + * Asynchronous event registration and handling + * + * @author Citrix Systems, Inc. + */ +public class Event extends XenAPIObject { + + /** + * The XenAPI reference to this object. + */ + protected final String ref; + + /** + * For internal use only. + */ + Event(String ref) { + this.ref = ref; + } + + public String toWireString() { + return this.ref; + } + + /** + * If obj is a Event, compares XenAPI references for equality. + */ + @Override + public boolean equals(Object obj) + { + if (obj != null && obj instanceof Event) + { + Event other = (Event) obj; + return other.ref.equals(this.ref); + } else + { + return false; + } + } + + @Override + public int hashCode() + { + return ref.hashCode(); + } + + /** + * Represents all the fields in a Event + */ + 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", "id", this.id); + print.printf("%1$20s: %2$s\n", "timestamp", this.timestamp); + print.printf("%1$20s: %2$s\n", "clazz", this.clazz); + print.printf("%1$20s: %2$s\n", "operation", this.operation); + print.printf("%1$20s: %2$s\n", "ref", this.ref); + print.printf("%1$20s: %2$s\n", "objUuid", this.objUuid); + print.printf("%1$20s: %2$s\n", "snapshot", this.snapshot); + return writer.toString(); + } + + /** + * Convert a event.Record to a Map + */ + public Map<String,Object> toMap() { + Map<String,Object> map = new HashMap<String,Object>(); + map.put("id", this.id == null ? 0 : this.id); + map.put("timestamp", this.timestamp == null ? new Date(0) : this.timestamp); + map.put("class", this.clazz == null ? "" : this.clazz); + map.put("operation", this.operation == null ? Types.EventOperation.UNRECOGNIZED : this.operation); + map.put("ref", this.ref == null ? "" : this.ref); + map.put("obj_uuid", this.objUuid == null ? "" : this.objUuid); + map.put("snapshot", this.snapshot); + return map; + } + + /** + * An ID, monotonically increasing, and local to the current session + */ + public Long id; + /** + * The time at which the event occurred + */ + public Date timestamp; + /** + * The name of the class of the object that changed + */ + public String clazz; + /** + * The operation that was performed + */ + public Types.EventOperation operation; + /** + * A reference to the object that changed + */ + public String ref; + /** + * The uuid of the object that changed + */ + public String objUuid; + /** + * The record of the database object that was added, changed or deleted + * (the actual type will be VM.Record, VBD.Record or similar) + */ + public Object snapshot; + } + + /** + * Registers this session with the event system. Specifying the empty list will register for all classes. + * + * @param classes register for events for the indicated classes + * @return Task + */ + public static Task registerAsync(Connection c, Set<String> classes) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "Async.event.register"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(classes)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toTask(result); + } + + /** + * Registers this session with the event system. Specifying the empty list will register for all classes. + * + * @param classes register for events for the indicated classes + */ + public static void register(Connection c, Set<String> classes) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "event.register"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(classes)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Unregisters this session with the event system + * + * @param classes remove this session's registration for the indicated classes + * @return Task + */ + public static Task unregisterAsync(Connection c, Set<String> classes) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "Async.event.unregister"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(classes)}; + Map response = c.dispatch(method_call, method_params); + Object result = response.get("Value"); + return Types.toTask(result); + } + + /** + * Unregisters this session with the event system + * + * @param classes remove this session's registration for the indicated classes + */ + public static void unregister(Connection c, Set<String> classes) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "event.unregister"; + String session = c.getSessionReference(); + Object[] method_params = {Marshalling.toXMLRPC(session), Marshalling.toXMLRPC(classes)}; + Map response = c.dispatch(method_call, method_params); + return; + } + + /** + * Blocking call which returns a (possibly empty) batch of events + * + * @return the batch of events + */ + public static Set<Event.Record> next(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException, + Types.SessionNotRegistered, + Types.EventsLost { + String method_call = "event.next"; + 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.toSetOfEventRecord(result); + } + + /** + * Return the ID of the next event to be generated by the system + * + * @return the event ID + */ + public static Long getCurrentId(Connection c) throws + BadServerResponse, + XenAPIException, + XmlRpcException { + String method_call = "event.get_current_id"; + 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.toLong(result); + } + +}
