diff options
Diffstat (limited to 'src/share/classes/sun/rmi/transport/DGCImpl.java')
| -rw-r--r-- | src/share/classes/sun/rmi/transport/DGCImpl.java | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/src/share/classes/sun/rmi/transport/DGCImpl.java b/src/share/classes/sun/rmi/transport/DGCImpl.java new file mode 100644 index 000000000..7b771fc42 --- /dev/null +++ b/src/share/classes/sun/rmi/transport/DGCImpl.java @@ -0,0 +1,340 @@ +/* + * Copyright 1996-2005 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ +package sun.rmi.transport; + +import java.rmi.Remote; +import java.rmi.RemoteException; +import java.rmi.dgc.DGC; +import java.rmi.dgc.Lease; +import java.rmi.dgc.VMID; +import java.rmi.server.LogStream; +import java.rmi.server.ObjID; +import java.rmi.server.RemoteServer; +import java.rmi.server.ServerNotActiveException; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.Future; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import sun.rmi.runtime.Log; +import sun.rmi.runtime.RuntimeUtil; +import sun.rmi.server.UnicastRef; +import sun.rmi.server.UnicastServerRef; +import sun.rmi.server.Util; +import sun.security.action.GetLongAction; +import sun.security.action.GetPropertyAction; + +/** + * This class implements the guts of the server-side distributed GC + * algorithm + * + * @author Ann Wollrath + */ +final class DGCImpl implements DGC { + + /* dgc system log */ + static final Log dgcLog = Log.getLog("sun.rmi.dgc", "dgc", + LogStream.parseLevel(AccessController.doPrivileged( + new GetPropertyAction("sun.rmi.dgc.logLevel")))); + + /** lease duration to grant to clients */ + private static final long leaseValue = // default 10 minutes + AccessController.doPrivileged( + new GetLongAction("java.rmi.dgc.leaseValue", 600000)); + + /** lease check interval; default is half of lease grant duration */ + private static final long leaseCheckInterval = + AccessController.doPrivileged( + new GetLongAction("sun.rmi.dgc.checkInterval", leaseValue / 2)); + + /** thread pool for scheduling delayed tasks */ + private static final ScheduledExecutorService scheduler = + AccessController.doPrivileged( + new RuntimeUtil.GetInstanceAction()).getScheduler(); + + /** remote implementation of DGC interface for this VM */ + private static DGCImpl dgc; + /** table that maps VMID to LeaseInfo */ + private Map<VMID,LeaseInfo> leaseTable = new HashMap<VMID,LeaseInfo>(); + /** checks for lease expiration */ + private Future<?> checker = null; + + /** + * Return the remote implementation of the DGC interface for + * this VM. + */ + static DGCImpl getDGCImpl() { + return dgc; + } + + /** + * Construct a new server-side remote object collector at + * a particular port. Disallow construction from outside. + */ + private DGCImpl() {} + + /** + * The dirty call adds the VMID "vmid" to the set of clients + * that hold references to the object associated with the ObjID + * id. The long "sequenceNum" is used to detect late dirty calls. If + * the VMID "vmid" is null, a VMID will be generated on the + * server (for use by the client in subsequent calls) and + * returned. + * + * The client must call the "dirty" method to renew the lease + * before the "lease" time expires or all references to remote + * objects in this VM that the client holds are considered + * "unreferenced". + */ + public Lease dirty(ObjID[] ids, long sequenceNum, Lease lease) { + VMID vmid = lease.getVMID(); + /* + * The server specifies the lease value; the client has + * no say in the matter. + */ + long duration = leaseValue; + + if (dgcLog.isLoggable(Log.VERBOSE)) { + dgcLog.log(Log.VERBOSE, "vmid = " + vmid); + } + + // create a VMID if one wasn't supplied + if (vmid == null) { + vmid = new VMID(); + + if (dgcLog.isLoggable(Log.BRIEF)) { + String clientHost; + try { + clientHost = RemoteServer.getClientHost(); + } catch (ServerNotActiveException e) { + clientHost = "<unknown host>"; + } + dgcLog.log(Log.BRIEF, " assigning vmid " + vmid + + " to client " + clientHost); + } + } + + lease = new Lease(vmid, duration); + // record lease information + synchronized (leaseTable) { + LeaseInfo info = leaseTable.get(vmid); + if (info == null) { + leaseTable.put(vmid, new LeaseInfo(vmid, duration)); + if (checker == null) { + checker = scheduler.scheduleWithFixedDelay( + new Runnable() { + public void run() { + checkLeases(); + } + }, + leaseCheckInterval, + leaseCheckInterval, TimeUnit.MILLISECONDS); + } + } else { + info.renew(duration); + } + } + + for (ObjID id : ids) { + if (dgcLog.isLoggable(Log.VERBOSE)) { + dgcLog.log(Log.VERBOSE, "id = " + id + + ", vmid = " + vmid + ", duration = " + duration); + } + + ObjectTable.referenced(id, sequenceNum, vmid); + } + + // return the VMID used + return lease; + } + + /** + * The clean call removes the VMID from the set of clients + * that hold references to the object associated with the LiveRef + * ref. The sequence number is used to detect late clean calls. If the + * argument "strong" is true, then the clean call is a result of a + * failed "dirty" call, thus the sequence number for the VMID needs + * to be remembered until the client goes away. + */ + public void clean(ObjID[] ids, long sequenceNum, VMID vmid, boolean strong) + { + for (ObjID id : ids) { + if (dgcLog.isLoggable(Log.VERBOSE)) { + dgcLog.log(Log.VERBOSE, "id = " + id + + ", vmid = " + vmid + ", strong = " + strong); + } + + ObjectTable.unreferenced(id, sequenceNum, vmid, strong); + } + } + + /** + * Register interest in receiving a callback when this VMID + * becomes inaccessible. + */ + void registerTarget(VMID vmid, Target target) { + synchronized (leaseTable) { + LeaseInfo info = leaseTable.get(vmid); + if (info == null) { + target.vmidDead(vmid); + } else { + info.notifySet.add(target); + } + } + } + + /** + * Remove notification request. + */ + void unregisterTarget(VMID vmid, Target target) { + synchronized (leaseTable) { + LeaseInfo info = leaseTable.get(vmid); + if (info != null) { + info.notifySet.remove(target); + } + } + } + + /** + * Check if leases have expired. If a lease has expired, remove + * it from the table and notify all interested parties that the + * VMID is essentially "dead". + * + * @return if true, there are leases outstanding; otherwise leases + * no longer need to be checked + */ + private void checkLeases() { + long time = System.currentTimeMillis(); + + /* List of vmids that need to be removed from the leaseTable */ + List<LeaseInfo> toUnregister = new ArrayList<LeaseInfo>(); + + /* Build a list of leaseInfo objects that need to have + * targets removed from their notifySet. Remove expired + * leases from leaseTable. + */ + synchronized (leaseTable) { + Iterator<LeaseInfo> iter = leaseTable.values().iterator(); + while (iter.hasNext()) { + LeaseInfo info = iter.next(); + if (info.expired(time)) { + toUnregister.add(info); + iter.remove(); + } + } + + if (leaseTable.isEmpty()) { + checker.cancel(false); + checker = null; + } + } + + /* Notify and unegister targets without holding the lock on + * the leaseTable so we avoid deadlock. + */ + for (LeaseInfo info : toUnregister) { + for (Target target : info.notifySet) { + target.vmidDead(info.vmid); + } + } + } + + static { + /* + * "Export" the singleton DGCImpl in a context isolated from + * the arbitrary current thread context. + */ + AccessController.doPrivileged(new PrivilegedAction<Void>() { + public Void run() { + ClassLoader savedCcl = + Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader( + ClassLoader.getSystemClassLoader()); + + /* + * Put remote collector object in table by hand to prevent + * listen on port. (UnicastServerRef.exportObject would + * cause transport to listen.) + */ + try { + dgc = new DGCImpl(); + ObjID dgcID = new ObjID(ObjID.DGC_ID); + LiveRef ref = new LiveRef(dgcID, 0); + UnicastServerRef disp = new UnicastServerRef(ref); + Remote stub = + Util.createProxy(DGCImpl.class, + new UnicastRef(ref), true); + disp.setSkeleton(dgc); + Target target = + new Target(dgc, disp, stub, dgcID, true); + ObjectTable.putTarget(target); + } catch (RemoteException e) { + throw new Error( + "exception initializing server-side DGC", e); + } + } finally { + Thread.currentThread().setContextClassLoader(savedCcl); + } + return null; + } + }); + } + + private static class LeaseInfo { + VMID vmid; + long expiration; + Set<Target> notifySet = new HashSet<Target>(); + + LeaseInfo(VMID vmid, long lease) { + this.vmid = vmid; + expiration = System.currentTimeMillis() + lease; + } + + synchronized void renew(long lease) { + long newExpiration = System.currentTimeMillis() + lease; + if (newExpiration > expiration) + expiration = newExpiration; + } + + boolean expired(long time) { + if (expiration < time) { + if (dgcLog.isLoggable(Log.BRIEF)) { + dgcLog.log(Log.BRIEF, vmid.toString()); + } + return true; + } else { + return false; + } + } + } +} |