/*
* Copyright (c) 1996, 2005, Oracle and/or its affiliates. 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.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;
}
}
}
}