In-memory databases can now run inside the Google App Engine.

h2/src/main/org/h2/engine/Database.java

@@ -222,8 +222,8 @@ public class Database implements DataHandler {
         try {
             open(traceLevelFile, traceLevelSystemOut);
             if (closeAtVmShutdown) {
-                closeOnExit = new DatabaseCloser(this, 0, true);
                 try {
+                    closeOnExit = new DatabaseCloser(this, 0, true);
                     Runtime.getRuntime().addShutdownHook(closeOnExit);
                 } catch (IllegalStateException e) {
                     // shutdown in progress - just don't register the handler
@@ -231,6 +231,8 @@ public class Database implements DataHandler {
                     // database at shutdown time)
                 } catch (SecurityException  e) {
                     // applets may not do that - ignore
+                    // Google App Engine doesn't allow
+                    // to instantiate classes that extend Thread
                 }
             }
         } catch (Throwable e) {

h2/src/main/org/h2/store/WriterThread.java

@@ -25,7 +25,7 @@ import org.h2.util.ObjectArray;
  * The writer thread is responsible to flush the transaction log file from time
  * to time.
  */
-public class WriterThread extends Thread {
+public class WriterThread implements Runnable {
 
     /**
      * The reference to the database.
@@ -74,11 +74,12 @@ public class WriterThread extends Thread {
      * @return the writer thread object
      */
     public static WriterThread create(Database database, int writeDelay) {
-        WriterThread thread = new WriterThread(database, writeDelay);
+        WriterThread writer = new WriterThread(database, writeDelay);
+        Thread thread = new Thread(writer);
         thread.setName("H2 Log Writer " + database.getShortName());
         thread.setDaemon(true);
         thread.start();
-        return thread;
+        return writer;
     }
 
     private LogSystem getLog() {

h2/src/main/org/h2/util/RandomUtils.java

@@ -10,7 +10,6 @@ import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Method;
-import java.net.InetAddress;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.util.Random;
@@ -65,24 +64,31 @@ public class RandomUtils {
                     }
                 }
             };
-            Thread t = new Thread(runnable);
-            // let the process terminate even if generating the seed is really slow
-            t.setDaemon(true);
-            t.start();
-            Thread.yield();
             try {
-                // normally, generateSeed takes less than 200 ms
-                t.join(400);
-            } catch (InterruptedException e) {
-                warn("InterruptedException", e);
-            }
-            if (!seeded) {
-                byte[] seed = generateAlternativeSeed();
-                // this never reduces randomness
-                synchronized (cachedSecureRandom) {
-                    cachedSecureRandom.setSeed(seed);
+                Thread t = new Thread(runnable);
+                // let the process terminate even if generating the seed is really slow
+                t.setDaemon(true);
+                t.start();
+                Thread.yield();
+                try {
+                    // normally, generateSeed takes less than 200 ms
+                    t.join(400);
+                } catch (InterruptedException e) {
+                    warn("InterruptedException", e);
+                }
+                if (!seeded) {
+                    byte[] seed = generateAlternativeSeed();
+                    // this never reduces randomness
+                    synchronized (cachedSecureRandom) {
+                        cachedSecureRandom.setSeed(seed);
+                    }
                 }
+            } catch (SecurityException e) {
+                // workaround for the Google App Engine: don't use a thread
+                runnable.run();
+                generateAlternativeSeed();
             }
+
         } catch (NoSuchAlgorithmException e) {
             warn("SecureRandom", e);
             cachedSecureRandom = new SecureRandom();
@@ -125,18 +131,27 @@ public class RandomUtils {
 
             // host name and ip addresses (if any)
             try {
-                String hostName = InetAddress.getLocalHost().getHostName();
+                // workaround for the Google App Engine: don't use InetAddress
+                Class inetAddressClass = Class.forName("java.net.InetAddress");
+                Object localHost = inetAddressClass.getMethod(
+                        "getLocalHost", new Class[0]).invoke(null, new Object[0]);
+                String hostName = inetAddressClass.getMethod(
+                        "getHostName", new Class[0]).invoke(localHost, new Object[0]).toString();
                 out.writeUTF(hostName);
-                InetAddress[] list = InetAddress.getAllByName(hostName);
+                Object[] list = (Object[]) inetAddressClass.getMethod(
+                        "getAllByName", new Class[] { String.class })
+                        .invoke(null, new Object[] { hostName });
+                Method getAddress = inetAddressClass.getMethod("getAddress", new Class[0]);
                 for (int i = 0; i < list.length; i++) {
-                    out.write(list[i].getAddress());
+                    out.write((byte[]) getAddress.invoke(list[i], new Object[0]));
                 }
-            } catch (Exception e) {
+            } catch (Throwable e) {
+                // on some system, InetAddress is not supported
                 // on some system, InetAddress.getLocalHost() doesn't work
                 // for some reason (incorrect configuration)
             }
 
-            // timing (a second thread is already running)
+            // timing (a second thread is already running usually)
             for (int j = 0; j < 16; j++) {
                 int i = 0;
                 long end = System.currentTimeMillis();