diff --git a/src/main/java/org/libvirt/Connect.java b/src/main/java/org/libvirt/Connect.java index 04de4fd..e427c5f 100644 --- a/src/main/java/org/libvirt/Connect.java +++ b/src/main/java/org/libvirt/Connect.java @@ -32,6 +32,7 @@ import com.sun.jna.NativeLong; import com.sun.jna.Pointer; import com.sun.jna.ptr.LongByReference; +import com.sun.jna.ptr.PointerByReference; /** * The Connect object represents a connection to a local or remote @@ -969,6 +970,13 @@ public String findStoragePoolSources(String type, String srcSpecs, int flags) th return processError(returnValue).toString(); } + + public DomainStatsRecords getAllDomainStats(int stats, int flags) throws LibvirtException { + PointerByReference retStats = new PointerByReference(); + int numRecords = processError(libvirt.virConnectGetAllDomainStats(VCP, stats, retStats, flags)); + return new DomainStatsRecords(retStats.getValue(), numRecords, this); + } + /** * Provides capabilities of the hypervisor / driver. * diff --git a/src/main/java/org/libvirt/Domain.java b/src/main/java/org/libvirt/Domain.java index 83a500c..740acca 100644 --- a/src/main/java/org/libvirt/Domain.java +++ b/src/main/java/org/libvirt/Domain.java @@ -16,6 +16,7 @@ import org.libvirt.jna.virDomainJobInfo; import org.libvirt.jna.virDomainMemoryStats; import org.libvirt.jna.virSchedParameter; +import org.libvirt.jna.virTypedParameter; import org.libvirt.jna.virVcpuInfo; import org.libvirt.event.RebootListener; import org.libvirt.event.LifecycleListener; @@ -256,6 +257,23 @@ public void attachDevice(String xmlDesc) throws LibvirtException { processError(libvirt.virDomainAttachDevice(VDP, xmlDesc)); } + /** + * Set domain metadata. + * + * @param xmlDesc + * XML description of the metadata + * @param flags + * the an OR'ed set of virDomainModificationImpact + * @param key + * XML namespace key + * @param uri + * XML namespace URI + * @throws LibvirtException + */ + public void setMetadata(String xmlDesc, String key, String uri, int flags) throws LibvirtException { + processError(libvirt.virDomainSetMetadata(VDP, 2, xmlDesc, key, uri, flags)); + } + /** * Creates a virtual device attachment to backend. * @@ -1337,6 +1355,21 @@ public void setMemory(long memory) throws LibvirtException { processError(libvirt.virDomainSetMemory(VDP, new NativeLong(memory))); } + /** + * Changes the scheduler parameters + * + * @param params + * an array of perf field to be set + * @throws LibvirtException + */ + public void SetPerfEvents(String[] params, int flags) throws LibvirtException { + virTypedParameter[] input = new virTypedParameter[params.length]; + for (int x = 0; x < params.length; x++) { + input[x] = TypedParameter.toNative(params[x]); + } + processError(libvirt.virDomainSetPerfEvents(VDP, input, params.length, flags)); + } + /** * Changes the scheduler parameters * diff --git a/src/main/java/org/libvirt/DomainStatsRecord.java b/src/main/java/org/libvirt/DomainStatsRecord.java new file mode 100644 index 0000000..52c40d7 --- /dev/null +++ b/src/main/java/org/libvirt/DomainStatsRecord.java @@ -0,0 +1,21 @@ +package org.libvirt; + +import java.util.List; + +public class DomainStatsRecord { + private Domain domain; + private List params; + + DomainStatsRecord(Domain d, List p) { + domain = d; + params = p; + } + + public Domain getDomain() { + return domain; + } + + public List getParams() { + return params; + } +} diff --git a/src/main/java/org/libvirt/DomainStatsRecords.java b/src/main/java/org/libvirt/DomainStatsRecords.java new file mode 100644 index 0000000..e9be85f --- /dev/null +++ b/src/main/java/org/libvirt/DomainStatsRecords.java @@ -0,0 +1,68 @@ +package org.libvirt; + +import static org.libvirt.Library.libvirt; + +import java.util.ArrayList; +import java.util.List; + +import org.libvirt.jna.virDomainStatsRecord; +import org.libvirt.jna.virTypedParameter; + +import com.sun.jna.Pointer; + +public class DomainStatsRecords { + private Pointer nativeArray; + private int arraySize; + private List statsRecords; + private Connect connect; + + public DomainStatsRecords(Pointer array, int size, Connect conn) { + nativeArray = array; + arraySize = size; + connect = conn; + LoadData(); + } + + private void LoadData() { + statsRecords = new ArrayList(); + if (arraySize <= 0) { + return; + } + virDomainStatsRecord firstRecord = new virDomainStatsRecord(nativeArray); + virDomainStatsRecord[] records = (virDomainStatsRecord[]) firstRecord.toArray(arraySize); + for (virDomainStatsRecord record : records) { + List paramList = new ArrayList(); + if (record.nparams > 0) { + virTypedParameter[] params = (virTypedParameter[]) record.params.toArray(record.nparams); + for (virTypedParameter param : params) { + paramList.add(TypedParameter.create(param)); + } + } + DomainStatsRecord r = new DomainStatsRecord(new Domain(connect, record.dom), paramList); + statsRecords.add(r); + } + } + + public List getStatsRecords() { + return statsRecords; + } + + @Override + protected void finalize() throws LibvirtException { + free(); + } + + /** + * Frees this stats object. + * structure is freed and should not be used thereafter. + * + * @throws LibvirtException + */ + public void free() throws LibvirtException { + if (nativeArray != null) { + libvirt.virDomainStatsRecordListFree(nativeArray); + nativeArray = null; + } + } + +} diff --git a/src/main/java/org/libvirt/TypedBooleanParameter.java b/src/main/java/org/libvirt/TypedBooleanParameter.java new file mode 100644 index 0000000..b5ff375 --- /dev/null +++ b/src/main/java/org/libvirt/TypedBooleanParameter.java @@ -0,0 +1,38 @@ +package org.libvirt; + +/** + * Class for representing a boolean typed parameter + * + * @author stoty + * + */ +public final class TypedBooleanParameter extends TypedParameter { + /** + * The parameter value + */ + public boolean value; + + public TypedBooleanParameter() { + + } + + public TypedBooleanParameter(boolean value) { + this.value = value; + } + + public TypedBooleanParameter(byte value) { + this.value = ((value) != 0) ? true : false; + } + + public int getType() { + return 6; + } + + public String getTypeAsString() { + return "VIR_TYPED_PARAM_BOOLEAN"; + } + + public String getValueAsString() { + return Boolean.toString(value); + } +} diff --git a/src/main/java/org/libvirt/TypedDoubleParameter.java b/src/main/java/org/libvirt/TypedDoubleParameter.java new file mode 100644 index 0000000..282bf8a --- /dev/null +++ b/src/main/java/org/libvirt/TypedDoubleParameter.java @@ -0,0 +1,34 @@ +package org.libvirt; + +/** + * Class for representing a double typed parameter + * + * @author stoty + * + */ +public final class TypedDoubleParameter extends TypedParameter { + /** + * The parameter value + */ + public double value; + + public TypedDoubleParameter() { + + } + + public TypedDoubleParameter(double value) { + this.value = value; + } + + public int getType() { + return 5; + } + + public String getTypeAsString() { + return "VIR_TYPED_PARAM_DOUBLE"; + } + + public String getValueAsString() { + return Double.toString(value); + } +} diff --git a/src/main/java/org/libvirt/TypedIntParameter.java b/src/main/java/org/libvirt/TypedIntParameter.java new file mode 100644 index 0000000..7952d7d --- /dev/null +++ b/src/main/java/org/libvirt/TypedIntParameter.java @@ -0,0 +1,28 @@ +package org.libvirt; + +/** + * Parameter to hold an int. + */ +public final class TypedIntParameter extends TypedParameter { + public int value; + + public TypedIntParameter() { + + } + + public TypedIntParameter(int value) { + this.value = value; + } + + public int getType() { + return 1; + } + + public String getTypeAsString() { + return "VIR_TYPED_PARAM_INT"; + } + + public String getValueAsString() { + return Integer.toString(value); + } +} diff --git a/src/main/java/org/libvirt/TypedLongParameter.java b/src/main/java/org/libvirt/TypedLongParameter.java new file mode 100644 index 0000000..c75155b --- /dev/null +++ b/src/main/java/org/libvirt/TypedLongParameter.java @@ -0,0 +1,35 @@ +package org.libvirt; + +/** + * Class for representing a long int typed parameter + * + * @author stoty + * + */ +public final class TypedLongParameter extends TypedParameter { + /** + * The parameter value + */ + public long value; + + public TypedLongParameter() { + + } + + public TypedLongParameter(long value) { + this.value = value; + } + + public int getType() { + return 3; + } + + public String getTypeAsString() { + return "VIR_TYPED_PARAM_LLONG"; + } + + public String getValueAsString() { + return Long.toString(value); + } + +} diff --git a/src/main/java/org/libvirt/TypedParameter.java b/src/main/java/org/libvirt/TypedParameter.java new file mode 100644 index 0000000..4104f51 --- /dev/null +++ b/src/main/java/org/libvirt/TypedParameter.java @@ -0,0 +1,133 @@ +package org.libvirt; + +import java.util.Arrays; + +import org.libvirt.jna.Libvirt; +import org.libvirt.jna.virTypedParameter; +import org.libvirt.jna.virTypedParameterValue; + +import com.sun.jna.Native; + +/** + * The abstract parent of the actual TypedParameter classes + * + * @author stoty + * + */ +public abstract class TypedParameter { + + public static TypedParameter create(virTypedParameter vParam) { + TypedParameter returnValue = null; + if (vParam != null) { + switch (vParam.type) { + case (1): + returnValue = new TypedIntParameter(vParam.value.i); + break; + case (2): + returnValue = new TypedUintParameter(vParam.value.i); + break; + case (3): + returnValue = new TypedLongParameter(vParam.value.l); + break; + case (4): + returnValue = new TypedUlongParameter(vParam.value.l); + break; + case (5): + returnValue = new TypedDoubleParameter(vParam.value.d); + break; + case (6): + returnValue = new TypedBooleanParameter(vParam.value.b); + break; + case (7): + returnValue = new TypedStringParameter(vParam.value.bptr); + break; + } + returnValue.field = Native.toString(vParam.field); + } + return returnValue; + } + + public static virTypedParameter toNative(TypedParameter param) { + virTypedParameter returnValue = new virTypedParameter(); + returnValue.value = new virTypedParameterValue(); + returnValue.field = copyOf(param.field.getBytes(), Libvirt.VIR_DOMAIN_SCHED_FIELD_LENGTH); + returnValue.type = param.getType(); + switch (param.getType()) { + case (1): + returnValue.value.i = ((TypedIntParameter) param).value; + returnValue.value.setType(int.class); + break; + case (2): + returnValue.value.i = ((TypedUintParameter) param).value; + returnValue.value.setType(int.class); + break; + case (3): + returnValue.value.l = ((TypedLongParameter) param).value; + returnValue.value.setType(long.class); + break; + case (4): + returnValue.value.l = ((TypedUlongParameter) param).value; + returnValue.value.setType(long.class); + break; + case (5): + returnValue.value.d = ((TypedDoubleParameter) param).value; + returnValue.value.setType(double.class); + break; + case (6): + returnValue.value.b = (byte) (((TypedBooleanParameter) param).value ? 1 : 0); + returnValue.value.setType(byte.class); + break; + case (7): + returnValue.value.bptr = ((TypedStringParameter) param).value.getBytes(); + returnValue.value.setType(byte[].class); + break; + } + return returnValue; + } + + public static virTypedParameter toNative(String param) { + virTypedParameter returnValue = new virTypedParameter(); + returnValue.value = new virTypedParameterValue(); + returnValue.field = copyOf(param.getBytes(), Libvirt.VIR_DOMAIN_SCHED_FIELD_LENGTH); + returnValue.type = 6; + returnValue.value.b = (byte) 1; + returnValue.value.setType(byte.class); + return returnValue; + } + + public static byte[] copyOf(byte[] original, int length) { + byte[] returnValue = new byte[length]; + int originalLength = original.length ; + Arrays.fill(returnValue, (byte)0); + for (int x = 0 ; x < originalLength ; x++) { + returnValue[x] = original[x] ; + } + return returnValue ; + } + + /** + * Parameter name + */ + public String field; + + /** + * The type of the parameter + * + * @return the Type of the parameter + */ + public abstract int getType(); + + /** + * Utility function for displaying the type + * + * @return the Type of the parameter as string + */ + public abstract String getTypeAsString(); + + /** + * Utility function for displaying the value + * + * @return the value of the parameter in String form + */ + public abstract String getValueAsString(); +} diff --git a/src/main/java/org/libvirt/TypedStringParameter.java b/src/main/java/org/libvirt/TypedStringParameter.java new file mode 100644 index 0000000..aad68e7 --- /dev/null +++ b/src/main/java/org/libvirt/TypedStringParameter.java @@ -0,0 +1,34 @@ +package org.libvirt; + +import com.sun.jna.Native; + +/** + * Parameter to hold a string. + */ +public final class TypedStringParameter extends TypedParameter { + public String value; + + public TypedStringParameter() { + + } + + public TypedStringParameter(String value) { + this.value = value; + } + + public TypedStringParameter(byte[] value) { + this.value = Native.toString(value); + } + + public int getType() { + return 7; + } + + public String getTypeAsString() { + return "VIR_TYPED_PARAM_STRING"; + } + + public String getValueAsString() { + return value; + } +} diff --git a/src/main/java/org/libvirt/TypedUintParameter.java b/src/main/java/org/libvirt/TypedUintParameter.java new file mode 100644 index 0000000..164d537 --- /dev/null +++ b/src/main/java/org/libvirt/TypedUintParameter.java @@ -0,0 +1,35 @@ +package org.libvirt; + +/** + * Class for representing an unsigned int typed parameter + * + * + * @author stoty + * + */ +public final class TypedUintParameter extends TypedParameter { + /** + * The parameter value + */ + public int value; + + public TypedUintParameter() { + + } + + public TypedUintParameter(int value) { + this.value = value; + } + + public int getType() { + return 2; + } + + public String getTypeAsString() { + return "VIR_TYPED_PARAM_UINT"; + } + + public String getValueAsString() { + return Integer.toString(value); + } +} diff --git a/src/main/java/org/libvirt/TypedUlongParameter.java b/src/main/java/org/libvirt/TypedUlongParameter.java new file mode 100644 index 0000000..3bbb3d6 --- /dev/null +++ b/src/main/java/org/libvirt/TypedUlongParameter.java @@ -0,0 +1,34 @@ +package org.libvirt; + +/** + * Class for representing an unsigned long int typed parameter + * + * @author stoty + * + */ +public final class TypedUlongParameter extends TypedParameter { + /** + * The parameter value + */ + public long value; + + public TypedUlongParameter() { + + } + + public TypedUlongParameter(long value) { + this.value = value; + } + + public int getType() { + return 4; + } + + public String getTypeAsString() { + return "VIR_TYPED_PARAM_ULLONG"; + } + + public String getValueAsString() { + return Long.toString(value); + } +} diff --git a/src/main/java/org/libvirt/jna/Libvirt.java b/src/main/java/org/libvirt/jna/Libvirt.java index 024e268..5227b59 100644 --- a/src/main/java/org/libvirt/jna/Libvirt.java +++ b/src/main/java/org/libvirt/jna/Libvirt.java @@ -11,6 +11,7 @@ import com.sun.jna.Structure; import com.sun.jna.ptr.IntByReference; import com.sun.jna.ptr.LongByReference; +import com.sun.jna.ptr.PointerByReference; import java.util.Arrays; import java.util.List; @@ -210,6 +211,7 @@ int virConnectRegisterCloseCallback(ConnectionPointer virConnectPtr, VirConnectC int virConnectIsEncrypted(ConnectionPointer virConnectPtr) ; int virConnectIsSecure(ConnectionPointer virConnectPtr) ; CString virConnectFindStoragePoolSources(ConnectionPointer virConnectPtr, String type, String srcSpec, int flags); + int virConnectGetAllDomainStats(ConnectionPointer virConnectPtr, int stats, PointerByReference retStats, int flags); CString virConnectGetCapabilities(ConnectionPointer virConnectPtr); CString virConnectGetHostname(ConnectionPointer virConnectPtr); int virConnectGetLibVersion(ConnectionPointer virConnectPtr, LongByReference libVer); @@ -342,9 +344,12 @@ int virDomainMigrateToURI2(DomainPointer virDomainPtr, String dconnuri, String m int virDomainSetAutostart(DomainPointer virDomainPtr, int autoStart); int virDomainSetMaxMemory(DomainPointer virDomainPtr, NativeLong maxMemory); int virDomainSetMemory(DomainPointer virDomainPtr, NativeLong maxMemory); + int virDomainSetMetadata(DomainPointer virDomainPtr, int type, String metadata, String key, String uri, int flags); + int virDomainSetPerfEvents(DomainPointer virDomainPtr, virTypedParameter[] params, int nparams, int flags); int virDomainSetSchedulerParameters(DomainPointer virDomainPtr, virSchedParameter[] params, int nparams); int virDomainSetVcpus(DomainPointer virDomainPtr, int nvcpus); int virDomainShutdown(DomainPointer virDomainPtr); + void virDomainStatsRecordListFree(Pointer ptr); int virDomainSuspend(DomainPointer virDomainPtr); int virDomainUpdateDeviceFlags(DomainPointer virDomainPtr, String xml, int flags); int virDomainUndefine(DomainPointer virDomainPtr); diff --git a/src/main/java/org/libvirt/jna/virDomainStatsRecord.java b/src/main/java/org/libvirt/jna/virDomainStatsRecord.java new file mode 100644 index 0000000..3b0948c --- /dev/null +++ b/src/main/java/org/libvirt/jna/virDomainStatsRecord.java @@ -0,0 +1,28 @@ +package org.libvirt.jna; + +import java.util.Arrays; +import java.util.List; + +import com.sun.jna.Pointer; +import com.sun.jna.Structure; + +/** + * JNA mapping for the virDomainStatsRecord structure + */ +public class virDomainStatsRecord extends Structure { + public DomainPointer dom; + public virTypedParameter.ByReference params; + public int nparams; + + private static final List fields = Arrays.asList( + "dom", "params", "nparams"); + + public virDomainStatsRecord(Pointer nativeArray) { + super(nativeArray); + } + + @Override + protected List getFieldOrder() { + return fields; + } +} diff --git a/src/main/java/org/libvirt/jna/virTypedParameter.java b/src/main/java/org/libvirt/jna/virTypedParameter.java new file mode 100644 index 0000000..5337e50 --- /dev/null +++ b/src/main/java/org/libvirt/jna/virTypedParameter.java @@ -0,0 +1,24 @@ +package org.libvirt.jna; + +import java.util.Arrays; +import java.util.List; + +import com.sun.jna.Structure; + +/** + * JNA mapping for the virTypedParameter structure + */ +public class virTypedParameter extends Structure { + public class ByReference extends virTypedParameter implements Structure.ByReference { } + public byte field[] = new byte[Libvirt.VIR_DOMAIN_SCHED_FIELD_LENGTH]; + public int type; + public virTypedParameterValue value; + + private static final List fields = Arrays.asList( + "field", "type", "value"); + + @Override + protected List getFieldOrder() { + return fields; + } +} diff --git a/src/main/java/org/libvirt/jna/virTypedParameterValue.java b/src/main/java/org/libvirt/jna/virTypedParameterValue.java new file mode 100644 index 0000000..beea7e1 --- /dev/null +++ b/src/main/java/org/libvirt/jna/virTypedParameterValue.java @@ -0,0 +1,14 @@ +package org.libvirt.jna; + +import com.sun.jna.Union; + +/** + * JNA mapping for the virTypedParameterValue structure + */ +public class virTypedParameterValue extends Union { + public int i; /* data for integer case */ + public long l; /* data for long long integer case */ + public double d; /* data for double case */ + public byte b; /* data for char case */ + public byte[] bptr; /* data for char case */ +}