--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/sun/rmi/transport/DGCImpl.java Sat Dec 01 00:00:00 2007 +0000
@@ -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;
+ }
+ }
+ }
+}