Index: /trunk/src/VBox/Main/glue/glue-java.xsl =================================================================== --- /trunk/src/VBox/Main/glue/glue-java.xsl (revision 30987) +++ /trunk/src/VBox/Main/glue/glue-java.xsl (revision 30987) @@ -0,0 +1,3631 @@ + + + + + + + + + + + + + + + + + + + + /** + * Copyright (C) 2010 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + + + + * + * DO NOT EDIT! This is a generated file. + * Generated from: src/VBox/Main/idl/VirtualBox.xidl (VirtualBox's interface definitions in XML) + * Generator: src/VBox/Main/glue/glue-java.xsl + */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + , + + + ; + + + + + + private final int value; + + + value = v; + } + + public int value() { + return value; + } + + + + if (c.value == (int)v) { + return c; + } + } + throw new IllegalArgumentException(Long.toString(v)); + } + + + + + + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + IUnknown + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + void + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + void + + + + + + + + + + + + + + + + + + + + + + , + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + void + + + + + + + + + + + + + + + + + + + + + + + + + + + , + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + import java.math.BigInteger; + import java.util.List; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + import java.math.BigInteger; + import java.util.List; + + + + + + + + + + + + + + + + + + + + + + + import java.math.BigInteger; + import java.util.List; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +{ + public T value; + + public Holder() + { + } + public Holder(T value) + { + this.value = value; + } +} +]]> + + + + + + + + + + + +{ + public T value; + + public Holder() + { + } + public Holder(T value) + { + this.value = value; + } +} +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + wrap(short[] vals) { + if (vals==null || vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (short v : vals) { + ret.add(v); + } + return ret; + } + + public static List wrap(int[] vals) { + if (vals==null || vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (int v : vals) { + ret.add(v); + } + return ret; + } + + public static List wrap(long[] vals) { + if (vals==null || vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (long v : vals) { + ret.add(v); + } + return ret; + } + + public static List wrap(String[] vals) { + if (vals==null || vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (String v : vals) { + ret.add(v); + } + return ret; + } + + public static List wrap(Class wrapperClass, T[] thisPtrs) { + if (thisPtrs==null || thisPtrs.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(thisPtrs.length); + for (T thisPtr : thisPtrs) { + ret.add(thisPtr); + } + return ret; + } + + public static List wrapEnum(Class wrapperClass, long values[]) { + try { + if (values==null) + return null; + Constructor c = wrapperClass.getConstructor(int.class); + List ret = new ArrayList(values.length); + for (long v : values) { + ret.add(c.newInstance(v)); + } + return ret; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (InstantiationException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static List wrapUnsignedLongLong(double vals[]) { + List ret = new ArrayList(vals.length); + for (double v : vals) { + ret.add(doubleToBigInteger(v)); + } + return ret; + } + + + public static short[] unwrap(List vals) { + if (vals==null || vals.size() == 0) return new short[0]; + + short[] ret = new short[vals.size()]; + int i = 0; + for (short l : vals) { + ret[i++] = l; + } + return ret; + } + + public static int[] unwrap(List vals) { + if (vals==null || vals.size() == 0) return new int[0]; + + int[] ret = new int[vals.size()]; + int i = 0; + for (int l : vals) { + ret[i++] = l; + } + return ret; + } + + public static long[] unwrap(List vals) { + if (vals==null || vals.size() == 0) return new long[0]; + + long[] ret = new long[vals.size()]; + int i = 0; + for (long l : vals) { + ret[i++] = l; + } + return ret; + } + + public static boolean[] unwrap(List vals) { + if (vals==null || vals.size() == 0) return new boolean[0]; + + boolean[] ret = new boolean[vals.size()]; + int i = 0; + for (boolean l : vals) { + ret[i++] = l; + } + return ret; + } + + public static String[] unwrap(List vals) { + if (vals==null || vals.size() == 0) return new String[0]; + + String[] ret = new String[vals.size()]; + int i = 0; + for (String l : vals) { + ret[i++] = l; + } + return ret; + } + + public static > long[] unwrapEnum(Class enumClass, List values) { + if (values == null) return null; + + long result[] = new long[values.size()]; + try { + java.lang.reflect.Method valueM = enumClass.getMethod("value"); + int i = 0; + for (T v : values) { + result[i++] = (Integer)valueM.invoke(v); + } + return result; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch(SecurityException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (IllegalArgumentException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static List wrap2(Class wrapperClass1, Class wrapperClass2, T2[] thisPtrs) { + try { + if (thisPtrs==null || thisPtrs.length == 0) return Collections.emptyList(); + + Constructor c = wrapperClass1.getConstructor(wrapperClass2); + List ret = new ArrayList(thisPtrs.length); + for (T2 thisPtr : thisPtrs) { + ret.add(c.newInstance(thisPtr)); + } + return ret; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (InstantiationException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static T[] unwrap(Class wrapperClass, List thisPtrs) { + if (thisPtrs==null) + return null; + if (thisPtrs.size() == 0) + return null; + return (T[])thisPtrs.toArray((T[])Array.newInstance(wrapperClass, thisPtrs.size())); + } + + public static T queryInterface(Object obj, String uuid, Class iface) + { + return (T)queryInterface(obj, uuid); + } + + public static Object queryInterface(Object obj, String uuid) + { + try { + /* Kind of ugly, but does the job of casting */ + org.mozilla.xpcom.Mozilla moz = org.mozilla.xpcom.Mozilla.getInstance(); + long xpobj = moz.wrapJavaObject(obj, uuid); + return moz.wrapXPCOMObject(xpobj, uuid); + } catch (Exception e) { + return null; + } + } + + public static T2[] unwrap2(Class wrapperClass1, Class wrapperClass2, List thisPtrs) { + if (thisPtrs==null || thisPtrs.size() == 0) return null; + + T2 ret[] = (T2[])Array.newInstance(wrapperClass2, thisPtrs.size()); + int i = 0; + for (T1 obj : thisPtrs) { + ret[i++] = (T2)obj.getWrapped(); + } + return ret; + } + + /* We do loose precision here */ + public static BigInteger doubleToBigInteger(double val) { + return new BigInteger(Long.toString((long)val)); + } + public static double bigIntegerToDouble(BigInteger val) { + return val.doubleValue(); + } +} +]]> + + + + + + + + + + + = end) + return false; + } + + return true; + } + + public boolean startVm(String name, String type, int timeout) + { + IMachine m = vbox.findMachine(name); + if (m == null) + return false; + ISession session = getSessionObject(); + + String mid = m.getId(); + if (type == null) + type = "gui"; + IProgress p = vbox.openRemoteSession(session, mid, type, ""); + progressBar(p, timeout); + session.close(); + return true; + } + + public void waitForEvents(long tmo) + { + mozilla.waitForEvents(tmo); + } +} +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + wrap(short[] vals) { + if (vals==null) return null; + if (vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (short v : vals) { + ret.add(v); + } + return ret; + } + + public static List wrap(int[] vals) { + if (vals == null) return null; + if (vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (int v : vals) { + ret.add(v); + } + return ret; + } + + public static List wrap(long[] vals) { + if (vals==null) return null; + if (vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (long v : vals) { + ret.add(v); + } + return ret; + } + + public static List wrap(String[] vals) { + if (vals==null) return null; + if (vals.length == 0) return Collections.emptyList(); + + List ret = new ArrayList(vals.length); + for (String v : vals) { + ret.add(v); + } + return ret; + } + + public static T wrapDispatch(Class wrapperClass, Dispatch d) + { + try { + if (d == null || d.m_pDispatch == 0) + return null; + Constructor c = wrapperClass.getConstructor(Dispatch.class); + return (T)c.newInstance(d); + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (InstantiationException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static Object wrapVariant(Class wrapperClass, Variant v) + { + if (v == null) + return null; + + short vt = v.getvt(); + switch (vt) + { + case Variant.VariantNull: + return null; + case Variant.VariantBoolean: + return v.getBoolean(); + case Variant.VariantByte: + return v.getByte(); + case Variant.VariantShort: + return v.getShort(); + case Variant.VariantInt: + return v.getInt(); + case Variant.VariantLongInt: + return v.getLong(); + case Variant.VariantString: + return v.getString(); + case Variant.VariantDispatch: + return wrapDispatch(wrapperClass, v.getDispatch()); + default: + throw new RuntimeException("unhandled variant type "+vt); + } + } + + public static List wrap(Class wrapperClass, SafeArray sa) { + if (sa==null) return null; + + int saLen = sa.getUBound() - sa.getLBound() + 1; + if (saLen == 0) return Collections.emptyList(); + + List ret = new ArrayList(saLen); + for (int i = sa.getLBound(); i <= sa.getUBound(); i++) + { + Variant v = sa.getVariant(i); + ret.add((T)wrapVariant(wrapperClass, v)); + } + return ret; + } + + public static List wrapEnum(Class wrapperClass, SafeArray sa) { + try { + if (sa==null) return null; + + int saLen = sa.getUBound() - sa.getLBound() + 1; + if (saLen == 0) return Collections.emptyList(); + List ret = new ArrayList(saLen); + Constructor c = wrapperClass.getConstructor(int.class); + for (int i = sa.getLBound(); i <= sa.getUBound(); i++) + { + Variant v = sa.getVariant(i); + ret.add(c.newInstance(v.getInt())); + } + return ret; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (InstantiationException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static SafeArray unwrapInt(List vals) { + if (vals==null) return null; + SafeArray ret = new SafeArray(Variant.VariantInt, vals.size()); + int i = 0; + for (int l : vals) { + ret.setInt(i++, l); + } + return ret; + } + + public static SafeArray unwrapLong(List vals) { + if (vals==null) return null; + SafeArray ret = new SafeArray(Variant.VariantLongInt, vals.size()); + int i = 0; + for (long l : vals) { + ret.setLong(i++, l); + } + return ret; + } + + public static SafeArray unwrapBool(List vals) { + if (vals==null) return null; + + SafeArray result = new SafeArray(Variant.VariantBoolean, vals.size()); + int i = 0; + for (boolean l : vals) { + result.setBoolean(i, l); + } + return result; + } + + public static > SafeArray unwrapEnum(Class enumClass, List values) { + if (values == null) return null; + + SafeArray result = new SafeArray(Variant.VariantInt, values.size()); + try { + java.lang.reflect.Method valueM = enumClass.getMethod("value"); + int i = 0; + for (T v : values) { + result.setInt(i, (Integer)valueM.invoke(v)); + } + return result; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch(SecurityException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (IllegalArgumentException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + public static SafeArray unwrapString(List vals) { + if (vals==null) + return null; + SafeArray result = new SafeArray(Variant.VariantString, vals.size()); + int i = 0; + for (String l : vals) { + result.setString(i, l); + } + return result; + } + + public static List wrap2(Class wrapperClass1, Class wrapperClass2, T2[] thisPtrs) { + try { + if (thisPtrs==null) return null; + if (thisPtrs.length == 0) return Collections.emptyList(); + + Constructor c = wrapperClass1.getConstructor(wrapperClass2); + List ret = new ArrayList(thisPtrs.length); + for (T2 thisPtr : thisPtrs) { + ret.add(c.newInstance(thisPtr)); + } + return ret; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (InstantiationException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static T[] unwrap(Class wrapperClass, List thisPtrs) { + if (thisPtrs==null) return null; + return (T[])thisPtrs.toArray((T[])Array.newInstance(wrapperClass, thisPtrs.size())); + } + + public static T2[] unwrap2(Class wrapperClass1, Class wrapperClass2, List thisPtrs) { + if (thisPtrs==null) return null; + + T2 ret[] = (T2[])Array.newInstance(wrapperClass2, thisPtrs.size()); + int i = 0; + for (T1 obj : thisPtrs) { + ret[i++] = (T2)obj.getWrapped(); + } + return ret; + } + + public static BigInteger longToBigInteger(long value) { + return BigInteger.valueOf(value); + } + + /* We have very long invoke lists sometimes */ + public static Variant invoke(Dispatch d, String method, Object ... args) + { + return Dispatch.callN(d, method, args); + } +} +]]> + + + + + + + + + + + + = end) + return false; + } + + return true; + } + + public boolean startVm(String name, String type, int timeout) + { + IMachine m = vbox.findMachine(name); + if (m == null) + return false; + ISession session = getSessionObject(); + + String mid = m.getId(); + if (type == null) + type = "gui"; + IProgress p = vbox.openRemoteSession(session, mid, type, ""); + progressBar(p, timeout); + session.close(); + return true; + } + + public void waitForEvents(long tmo) + { + // what to do here? + try { + Thread.sleep(tmo); + } catch (InterruptedException ie) { + } + } +} +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + List wrap(Class wrapperClass, VboxPortType pt, List thisPtrs) { + try { + if(thisPtrs==null) return null; + + Constructor c = wrapperClass.getConstructor(String.class, VboxPortType.class); + List ret = new ArrayList(thisPtrs.size()); + for (String thisPtr : thisPtrs) { + ret.add(c.newInstance(thisPtr,pt)); + } + return ret; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (InstantiationException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static List wrap2(Class wrapperClass1, Class wrapperClass2, VboxPortType pt, List thisPtrs) { + try { + if(thisPtrs==null) return null; + + Constructor c = wrapperClass1.getConstructor(wrapperClass2, VboxPortType.class); + List ret = new ArrayList(thisPtrs.size()); + for (T2 thisPtr : thisPtrs) { + ret.add(c.newInstance(thisPtr,pt)); + } + return ret; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (InstantiationException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } + + public static List unwrap(List thisPtrs) { + if (thisPtrs==null) return null; + + List ret = new ArrayList(thisPtrs.size()); + for (T obj : thisPtrs) { + ret.add(obj.getWrapped()); + } + return ret; + } + + public static , T2 extends Enum > List convertEnums(Class fromClass, + Class toClass, + List values) { + try { + if (values==null) + return null; + java.lang.reflect.Method fromValue = toClass.getMethod("fromValue", String.class); + List ret = new ArrayList(values.size()); + for (T1 v : values) { + // static method is called with null this + ret.add((T2)fromValue.invoke(null, v.name())); + } + return ret; + } catch (NoSuchMethodException e) { + throw new AssertionError(e); + } catch (IllegalAccessException e) { + throw new AssertionError(e); + } catch (InvocationTargetException e) { + throw new AssertionError(e); + } + } +} +]]> + + + + + + + + + + +import java.net.URL; +import java.math.BigInteger; +import java.util.List; +import java.util.Map; +import java.util.HashMap; +import javax.xml.namespace.QName; +import javax.xml.ws.BindingProvider; +import javax.xml.ws.Holder; +import javax.xml.ws.WebServiceException; + +class PortPool +{ + private final static String wsdlFile = ; + + known; + private boolean initStarted; + private VboxService svc; + + PortPool(boolean usePreinit) + { + known = new HashMap(); + + if (usePreinit) + { + new Thread(new Runnable() + { + public void run() + { + // need to sync on something else but 'this' + synchronized (known) + { + initStarted = true; + known.notify(); + } + + preinit(); + } + }).start(); + + synchronized (known) + { + while (!initStarted) + { + try { + known.wait(); + } catch (InterruptedException e) { + break; + } + } + } + } + } + + private synchronized void preinit() + { + VboxPortType port = getPort(); + releasePort(port); + } + + synchronized VboxPortType getPort() + { + VboxPortType port = null; + int ttl = 0; + + for (VboxPortType cur: known.keySet()) + { + int value = known.get(cur); + if ((value & 0x10000) == 0) + { + port = cur; + ttl = value & 0xffff; + break; + } + } + + if (port == null) + { + if (svc == null) { + URL wsdl = PortPool.class.getClassLoader().getResource(wsdlFile); + if (wsdl == null) + throw new LinkageError(wsdlFile+" not found, but it should have been in the jar"); + svc = new VboxService(wsdl, + new QName("http://www.virtualbox.org/Service", + "vboxService")); + } + port = svc.getVboxServicePort(); + // reuse this object 0x10 times + ttl = 0x10; + } + // mark as used + known.put(port, new Integer(0x10000 | ttl)); + return port; + } + + synchronized void releasePort(VboxPortType port) + { + Integer val = known.get(port); + if (val == null || val == 0) + { + // know you not + return; + } + + int v = val; + int ttl = v & 0xffff; + // decrement TTL, and throw away port if used too much times + if (--ttl <= 0) + { + known.remove(port); + } + else + { + v = ttl; // set new TTL and clear busy bit + known.put(port, v); + } + } +} + + +public class VirtualBoxManager +{ + private static PortPool pool = new PortPool(true); + protected VboxPortType port; + + private IVirtualBox vbox; + + private VirtualBoxManager() + { + } + + public static void initPerThread() + { + } + + public static void deinitPerThread() + { + } + + public void connect(String url, String username, String passwd) + { + this.port = pool.getPort(); + try { + ((BindingProvider)port).getRequestContext(). + put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url); + String handle = port.iWebsessionManagerLogon(username, passwd); + this.vbox = new IVirtualBox(handle, port); + } catch (Throwable t) { + if (this.port != null) + pool.releasePort(this.port); + // we have to throw smth derived from RuntimeException + throw new VBoxException(t, t.getMessage()); + } + } + + public void connect(String url, String username, String passwd, + Map requestContext, Map responseContext) + { + this.port = pool.getPort(); + + try { + ((BindingProvider)port).getRequestContext(); + if (requestContext != null) + ((BindingProvider)port).getRequestContext().putAll(requestContext); + + if (responseContext != null) + ((BindingProvider)port).getResponseContext().putAll(responseContext); + + ((BindingProvider)port).getRequestContext(). + put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url); + String handle = port.iWebsessionManagerLogon(username, passwd); + this.vbox = new IVirtualBox(handle, port); + } catch (Throwable t) { + if (this.port != null) + pool.releasePort(port); + // we have to throw smth derived from RuntimeException + throw new VBoxException(t, t.getMessage()); + } + } + + public void disconnect() + { + try { + if (this.vbox != null) + port.iWebsessionManagerLogoff(this.vbox.getWrapped()); + } catch (InvalidObjectFaultMsg e) { + throw new VBoxException(e, e.getMessage()); + } catch (RuntimeFaultMsg e) { + throw new VBoxException(e, e.getMessage()); + } finally { + if (this.port != null) { + pool.releasePort(this.port); + this.port = null; + } + } + } + + public IVirtualBox getVBox() + { + return this.vbox; + } + + public ISession getSessionObject() + { + if (this.vbox == null) + throw new RuntimeException("connect first"); + try { + String handle = port.iWebsessionManagerGetSessionObject(this.vbox.getWrapped()); + return new ISession(handle, port); + } catch (InvalidObjectFaultMsg e) { + throw new VBoxException(e, e.getMessage()); + } catch (RuntimeFaultMsg e) { + throw new VBoxException(e, e.getMessage()); + } + } + + public ISession openMachineSession(String mid) throws Exception + { + ISession s = getSessionObject(); + try { + this.vbox.openExistingSession(s, mid); + return s; + } catch (Exception e) { + try { + this.vbox.openSession(s, mid); + return s; + } catch (Exception e1) { + closeMachineSession(s); + throw e1; + } + } + } + + public ISession openMachineSession(IMachine m) throws Exception + { + return openMachineSession(m.getId()); + } + + public void closeMachineSession(ISession s) + { + if (s != null) + s.close(); + } + + private static VirtualBoxManager mgr; + + public static synchronized VirtualBoxManager getInstance(String home) + { + if (mgr != null) + return mgr; + + mgr = new VirtualBoxManager(); + return mgr; + } + + public IEventListener createListener(Object sink) + { + throw new RuntimeException("no active listeners here"); + } + public void cleanup() + { + deinitPerThread(); + } + + public boolean progressBar(IProgress p, int wait) + { + long end = System.currentTimeMillis() + wait; + while (!p.getCompleted()) + { + p.waitForCompletion(wait); + if (System.currentTimeMillis() >= end) + return false; + } + + return true; + } + + public boolean startVm(String name, String type, int timeout) + { + IMachine m = vbox.findMachine(name); + if (m == null) + return false; + ISession session = getSessionObject(); + + String mid = m.getId(); + if (type == null) + type = "gui"; + IProgress p = vbox.openRemoteSession(session, mid, type, ""); + progressBar(p, timeout); + session.close(); + return true; + } + + public void waitForEvents(long tmo) + { + } +} +]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +