package org.astrogrid.samp;
import java.util.Arrays;
import java.util.WeakHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Handles ordered running of cleanup processes at JVM shutdown.
* This is a singleton class, use {@link #getInstance}.
*
* @author Sylvain Lafrasse
* @author Mark Taylor
* @since 12 Oct 2012
*/
public class ShutdownManager {
/** Shutdown sequence for preparatory hooks. */
public static final int PREPARE_SEQUENCE = 0;
/** Shutdown sequence value for client hooks. */
public static final int CLIENT_SEQUENCE = 100;
/** Shutdown sequence value for hub hooks. */
public static final int HUB_SEQUENCE = 200;
private static final ShutdownManager instance_ = new ShutdownManager();
private static final Logger logger_ =
Logger.getLogger( "org.astrogrid.samp" );
/** Maps Objects to Hooks. */
private final WeakHashMap hookMap_;
/**
* Private constructor prevents instantiation.
*/
private ShutdownManager() {
hookMap_ = new WeakHashMap();
try {
Runtime.getRuntime()
.addShutdownHook( new Thread( "SAMP Shutdown" ) {
public void run() {
doCleanup();
}
} );
}
catch ( SecurityException e ) {
logger_.log( Level.WARNING, "Can't add shutdown hook: " + e, e );
}
}
/**
* Register a runnable to be run on shutdown with a given key and sequence.
* Items with a smaller value of iseq
* are run earlier at shutdown.
* Suitable sequence values are given by {@link #HUB_SEQUENCE} and
* {@link #CLIENT_SEQUENCE}.
* The key is kept in a WeakHashMap, so if it is GC'd,
* the runnable will never execute.
*
* @param key key which can be used to unregister the hook later
* @param iseq value indicating position in shutdown sequence
* @param runnable to be run on shutdown
*/
public synchronized void registerHook( Object key, int iseq,
Runnable runnable ) {
hookMap_.put( key, new Hook( runnable, iseq ) );
}
/**
* Unregisters a key earlier registered using {@link #registerHook}.
*
* @param key registration key
*/
public synchronized void unregisterHook( Object key ) {
hookMap_.remove( key );
}
/**
* Invoked on shutdown by runtime.
*/
private void doCleanup() {
Hook[] hooks;
synchronized ( this ) {
hooks = (Hook[]) hookMap_.values().toArray( new Hook[ 0 ] );
}
Arrays.sort( hooks );
logger_.info( "SAMP shutdown start" );
for ( int ih = 0; ih < hooks.length; ih++ ) {
try {
hooks[ ih ].runnable_.run();
}
catch ( RuntimeException e ) {
forceLog( logger_, Level.WARNING, "Shutdown hook failure: " + e,
e );
}
}
logger_.info( "SAMP shutdown end" );
}
/**
* Returns sole instance of this class.
*
* @return instance
*/
public static ShutdownManager getInstance() {
return instance_;
}
/**
* Writes a log-like message directly to standard error if it has
* an appropriate level.
* This method is only intended for use during the shutdown process,
* when the logging system may be turned off so that normal logging
* calls may get ignored (this behaviour is not as far as I know
* documented, but seems reliable in for example Oracle JRE1.5).
* There may be some good reason for logging services to be withdrawn
* during shutdown, so it's not clear that using this method is
* a good idea at all even apart from bypassing the logging system;
* therefore use it sparingly.
*
* @param logger logger
* @param level level of message to log
* @param msg text of logging message
* @param error associated throwable if any; may be null
*/
public static void forceLog( Logger logger, Level level, String msg,
Throwable error ) {
if ( logger.isLoggable( level ) ) {
System.err.println( level + ": " + msg );
if ( error != null ) {
error.printStackTrace( System.err );
}
}
}
/**
* Aggregates a runnable and an associated sequence value.
*/
private static class Hook implements Comparable {
final Runnable runnable_;
final int iseq_;
/**
* Constructor.
*
* @param runnable runnable
* @param iseq sequence value
*/
Hook( Runnable runnable, int iseq ) {
runnable_ = runnable;
iseq_ = iseq;
}
public int compareTo( Object other ) {
return this.iseq_ - ((Hook) other).iseq_;
}
}
}