--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/org/dancres/blitz/remote/perf/Proxy.java	Sat Mar 21 11:00:06 2009 +0000
@@ -0,0 +1,189 @@
+package org.dancres.blitz.remote.perf;
+
+import java.io.Serializable;
+
+import java.rmi.RemoteException;
+import java.rmi.MarshalledObject;
+
+import net.jini.space.JavaSpace;
+
+import net.jini.core.entry.Entry;
+import net.jini.core.entry.UnusableEntryException;
+
+import net.jini.core.transaction.Transaction;
+import net.jini.core.transaction.TransactionException;
+
+import net.jini.core.event.EventRegistration;
+import net.jini.core.event.RemoteEventListener;
+
+import net.jini.core.lease.Lease;
+
+import net.jini.lookup.entry.ServiceInfo;
+import net.jini.lookup.entry.Name;
+
+import com.sun.jini.lookup.entry.BasicServiceType;
+
+import net.jini.admin.Administrable;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.FileInputStream;
+
+import net.jini.id.Uuid;
+import net.jini.id.ReferentUuid;
+import net.jini.id.ReferentUuids;
+
+import org.dancres.blitz.mangler.EntryMangler;
+import org.dancres.blitz.mangler.MangledEntry;
+
+import org.dancres.blitz.VersionInfo;
+
+import com.sun.jini.proxy.MarshalledWrapper;
+
+/**
+ */
+class Proxy implements Serializable {
+    private Server theStub;
+    private transient EntryMangler theMangler;
+
+    public static void main(String anArgs[]) {
+        try {
+            String myStubFile = ServiceImpl.STUB_FILE;
+
+            if (anArgs.length > 1)
+                myStubFile = anArgs[1];
+
+            int myThreads = 1;
+
+            if (anArgs.length > 0)
+                myThreads = Integer.parseInt(anArgs[0]);
+
+            ObjectInputStream myOIS =
+                new ObjectInputStream(new FileInputStream(myStubFile));
+
+            Server myStub = (Server) myOIS.readObject();
+
+            System.out.println(myStub);
+
+            Proxy myProxy = new Proxy(myStub);
+
+            Thrasher[] myThrashers = new Thrasher[myThreads];
+
+            for (int i = 0; i < myThreads; i++) {
+                myThrashers[i] = new Thrasher(myProxy);
+                myThrashers[i].start();
+            }
+
+            new Watcher(myThrashers).start();
+
+        } catch (Exception anE) {
+            System.err.println("Failed to init proxy");
+            anE.printStackTrace(System.err);
+        }
+    }
+
+    private static class Watcher extends Thread {
+        private Thrasher[] theThrashers;
+
+        Watcher(Thrasher[] aThrashers) {
+            theThrashers = aThrashers;
+        }
+
+        public void run() {
+            while(true) {
+                try {
+                    Thread.sleep(60000);
+
+                    for (int i = 0; i < theThrashers.length; i++) {
+                        theThrashers[i].dumpCounts();
+                    }
+                } catch (InterruptedException anIE) {
+                    System.err.println("Dead watcher");
+                }
+            }
+        }
+    }
+
+    private static class Thrasher extends Thread {
+        private Proxy theProxy;
+        private long theCount;
+
+        Thrasher(Proxy aProxy) {
+            theProxy = aProxy;
+        }
+
+        public void run() {
+            while (true) {
+                try {
+                    DummyEntry myPackedEntry = new DummyEntry("rhubarb");
+
+                    theProxy.read(myPackedEntry, null, 0);
+                    theProxy.write(myPackedEntry, null, 0);
+
+                    synchronized(this) {
+                        ++theCount;
+                    }
+                } catch (Exception anE) {
+                    System.err.println("Thrasher died: " + anE);
+                }
+            }
+        }
+
+        public void dumpCounts() {
+            synchronized(this) {
+                System.out.println("Write/read combos: " + theCount);
+                theCount = 0;
+            }
+        }
+    }
+
+    Proxy(Server aServer) {
+        theStub = aServer;
+    }
+
+    private synchronized EntryMangler getMangler() {
+        if (theMangler == null)
+            theMangler = new EntryMangler();
+
+        return theMangler;
+    }
+
+    private MangledEntry packEntry(Entry anEntry) {
+        if (anEntry == null)
+            return MangledEntry.NULL_TEMPLATE;
+        // Is it a snapshot?
+        else if (anEntry instanceof MangledEntry)
+            return (MangledEntry) anEntry;
+        else
+            return getMangler().mangle(anEntry);
+    }
+
+    public Lease write(Entry entry, Transaction txn, long lease)
+        throws TransactionException, RemoteException {
+
+        return theStub.write(packEntry(entry), txn, lease);
+    }
+
+    public Entry read(Entry tmpl, Transaction txn, long timeout)
+        throws UnusableEntryException, TransactionException, 
+               InterruptedException, RemoteException {
+
+        MangledEntry myResult =
+            theStub.read(packEntry(tmpl), txn, timeout);
+
+        return (myResult != null) ?
+            getMangler().unMangle(myResult) : null;
+    }
+
+    static final class SnapshotEntry implements Entry {
+        private MangledEntry thePackage;
+
+        SnapshotEntry(MangledEntry aPackage) {
+            thePackage = aPackage;
+        }
+
+        MangledEntry getPackage() {
+            return thePackage;
+        }
+    }
+}