--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/org/dancres/blitz/remote/ConstrainableLeaseImpl.java	Sat Mar 21 11:00:06 2009 +0000
@@ -0,0 +1,91 @@
+package org.dancres.blitz.remote;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.InvalidObjectException;
+
+import java.lang.reflect.Method;
+
+import net.jini.id.Uuid;
+
+import net.jini.core.constraint.RemoteMethodControl;
+import net.jini.core.constraint.MethodConstraints;
+
+import net.jini.security.proxytrust.ProxyTrustIterator;
+import net.jini.security.proxytrust.SingletonProxyTrustIterator;
+
+import net.jini.core.lease.Lease;
+
+import net.jini.admin.JoinAdmin;
+
+import net.jini.id.Uuid;
+
+import com.sun.jini.proxy.ConstrainableProxyUtil;
+
+import org.dancres.blitz.lease.SpaceUID;
+
+import org.dancres.util.ReflectUtil;
+
+/**
+   When running in "secure mode", Leases should be constrainable as per
+   other proxies.
+ */
+public final class ConstrainableLeaseImpl extends
+    LeaseImpl implements RemoteMethodControl {
+
+    /**
+       The outer-layer calls all omit SpaceUID whilst the server
+       calls use SpaceUID so we must translate constraints which will be
+       applied against the outer-layer methods to the internal methods.
+     */
+    private static final Method[] theMethodMapping = {
+        ReflectUtil.findMethod(Lease.class, "renew",
+                               new Class[] {long.class}),
+        ReflectUtil.findMethod(Landlord.class, "renew",
+                               new Class[] {SpaceUID.class, long.class}),
+        ReflectUtil.findMethod(Lease.class, "cancel",
+                               new Class[] {}),
+        ReflectUtil.findMethod(Landlord.class, "cancel",
+                               new Class[] {SpaceUID.class})
+    };
+
+    private static Landlord constrainStub(Landlord aServer,
+                                          MethodConstraints aConstraints) {
+        RemoteMethodControl myServer = (RemoteMethodControl) aServer;
+
+        MethodConstraints myStubConstraints =
+            ConstrainableProxyUtil.translateConstraints(aConstraints,
+                                                        theMethodMapping);
+
+        myServer.setConstraints(myStubConstraints);
+        return (Landlord) myServer;
+    }
+
+    private final MethodConstraints theConstraints;
+
+    ConstrainableLeaseImpl(Landlord aLandlord, Uuid aUuid, SpaceUID aUID,
+                           long aDuration) {
+        super(aLandlord, aUuid, aUID, aDuration);
+        theConstraints = null;
+    }
+
+    ConstrainableLeaseImpl(Landlord aLandlord, Uuid aUuid, SpaceUID aUID,
+                           long aDuration, MethodConstraints aConstraints) {
+        super(constrainStub(aLandlord, aConstraints), aUuid, aUID,
+              aDuration);
+        theConstraints = aConstraints;
+    }
+
+    private ProxyTrustIterator getProxyTrustIterator() {
+        return new SingletonProxyTrustIterator(theStub);
+    }
+
+    public RemoteMethodControl setConstraints(MethodConstraints aConstraints) {
+        return new ConstrainableLeaseImpl(theStub, theUuid, getUID(),
+                                          expiration, aConstraints);
+    }
+
+    public MethodConstraints getConstraints() {
+        return theConstraints;
+    }
+}