package org.astrogrid.samp.xmlrpc; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.Iterator; import java.util.List; import java.util.Random; import java.util.Vector; import java.util.logging.Level; import java.util.logging.Logger; import org.astrogrid.samp.SampUtils; import org.astrogrid.samp.client.ClientProfile; import org.astrogrid.samp.client.DefaultClientProfile; import org.astrogrid.samp.client.HubConnection; import org.astrogrid.samp.client.SampException; import org.astrogrid.samp.hub.Hub; import org.astrogrid.samp.hub.HubService; import org.astrogrid.samp.hub.KeyGenerator; import org.astrogrid.samp.hub.LockWriter; import org.astrogrid.samp.hub.MessageRestriction; import org.astrogrid.samp.hub.ProfileToken; import org.astrogrid.samp.httpd.ServerResource; import org.astrogrid.samp.httpd.UtilServer; /** * Runs a SAMP hub using the SAMP Standard Profile. * The {@link #start} method must be called to start it up. * *
The {@link #main} method can be used to launch a hub from
* the command line. Use the -help flag for more information.
*
* @author Mark Taylor
* @since 15 Jul 2008
* @deprecated use {@link org.astrogrid.samp.hub.Hub} instead
*/
public class HubRunner {
private final SampXmlRpcClientFactory xClientFactory_;
private final SampXmlRpcServerFactory xServerFactory_;
private final HubService hub_;
private final File lockfile_;
private URL lockUrl_;
private LockInfo lockInfo_;
private SampXmlRpcServer server_;
private HubXmlRpcHandler hubHandler_;
private boolean shutdown_;
private final static ProfileToken STANDARD_PROFILE = new ProfileToken() {
public String getProfileName() {
return "Standard";
}
public MessageRestriction getMessageRestriction() {
return null;
}
};
private final static Logger logger_ =
Logger.getLogger( HubRunner.class.getName() );
private final static Random random_ = KeyGenerator.createRandom();
/**
* Constructor.
* If the supplied lockfile is null, no lockfile will
* be written at hub startup.
*
* @param xClientFactory XML-RPC client factory implementation
* @param xServerFactory XML-RPC server implementation
* @param hub object providing hub services
* @param lockfile location to use for hub lockfile, or null
*/
public HubRunner( SampXmlRpcClientFactory xClientFactory,
SampXmlRpcServerFactory xServerFactory,
HubService hub, File lockfile ) {
xClientFactory_ = xClientFactory;
xServerFactory_ = xServerFactory;
hub_ = hub;
lockfile_ = lockfile;
logger_.warning( "Class " + HubRunner.class.getName()
+ " is deprecated; use "
+ Hub.class.getName() + " instead." );
}
/**
* Starts the hub and writes the lockfile.
*
* @throws IOException if a hub is already running or an error occurs
*/
public void start() throws IOException {
// Check for running or moribund hub.
if ( lockfile_ != null && lockfile_.exists() ) {
if ( isHubAlive( xClientFactory_, lockfile_ ) ) {
throw new IOException( "A hub is already running" );
}
else {
logger_.warning( "Overwriting " + lockfile_ + " lockfile "
+ "for apparently dead hub" );
lockfile_.delete();
}
}
// Start up server.
try {
server_ = xServerFactory_.getServer();
}
catch ( IOException e ) {
throw e;
}
catch ( Exception e ) {
throw (IOException) new IOException( "Can't start XML-RPC server" )
.initCause( e );
}
// Start the hub service.
hub_.start();
String secret = createSecret();
ClientProfile connectionFactory = new ClientProfile() {
public HubConnection register() throws SampException {
return hub_.register( STANDARD_PROFILE );
}
public boolean isHubRunning() {
return hub_.isHubRunning();
}
};
hubHandler_ =
new HubXmlRpcHandler( xClientFactory_, connectionFactory, secret,
new KeyGenerator( "k:", 16, random_ ) );
server_.addHandler( hubHandler_ );
// Ensure tidy up in case of JVM shutdown.
Runtime.getRuntime().addShutdownHook(
new Thread( "HubRunner shutdown" ) {
public void run() {
shutdown();
}
} );
// Prepare lockfile information.
lockInfo_ = new LockInfo( secret, server_.getEndpoint().toString() );
lockInfo_.put( "hub.impl", hub_.getClass().getName() );
lockInfo_.put( "hub.start.date", new Date().toString() );
// Write lockfile information to file if required.
if ( lockfile_ != null ) {
logger_.info( "Writing new lockfile " + lockfile_ );
FileOutputStream out = new FileOutputStream( lockfile_ );
try {
writeLockInfo( lockInfo_, out );
try {
LockWriter.setLockPermissions( lockfile_ );
logger_.info( "Lockfile permissions set to "
+ "user access only" );
}
catch ( IOException e ) {
logger_.log( Level.WARNING,
"Failed attempt to change " + lockfile_
+ " permissions to user access only"
+ " - possible security implications", e );
}
}
finally {
try {
out.close();
}
catch ( IOException e ) {
logger_.log( Level.WARNING, "Error closing lockfile?", e );
}
}
}
}
/**
* Shuts down the hub and tidies up.
* May harmlessly be called multiple times.
*/
public synchronized void shutdown() {
// Return if we have already done this.
if ( shutdown_ ) {
return;
}
shutdown_ = true;
// Delete the lockfile if it exists and if it is the one originally
// written by this runner.
if ( lockfile_ != null ) {
if ( lockfile_.exists() ) {
try {
LockInfo lockInfo = readLockFile( lockfile_ );
if ( lockInfo.getSecret()
.equals( lockInfo_.getSecret() ) ) {
assert lockInfo.equals( lockInfo_ );
boolean deleted = lockfile_.delete();
logger_.info( "Lockfile " + lockfile_ + " "
+ ( deleted ? "deleted"
: "deletion attempt failed" ) );
}
else {
logger_.warning( "Lockfile " + lockfile_ + " has been "
+ " overwritten - not deleting" );
}
}
catch ( Throwable e ) {
logger_.log( Level.WARNING,
"Failed to delete lockfile " + lockfile_,
e );
}
}
else {
logger_.warning( "Lockfile " + lockfile_ + " has disappeared" );
}
}
// Withdraw service of the lockfile, if one has been published.
if ( lockUrl_ != null ) {
try {
UtilServer.getInstance().getResourceHandler()
.removeResource( lockUrl_ );
}
catch ( IOException e ) {
logger_.warning( "Failed to withdraw lockfile URL" );
}
lockUrl_ = null;
}
// Shut down the hub service if exists. This sends out shutdown
// messages to registered clients.
if ( hub_ != null ) {
try {
hub_.shutdown();
}
catch ( Throwable e ) {
logger_.log( Level.WARNING, "Hub service shutdown failed", e );
}
}
// Remove the hub XML-RPC handler from the server.
if ( hubHandler_ != null && server_ != null ) {
server_.removeHandler( hubHandler_ );
server_ = null;
}
lockInfo_ = null;
}
/**
* Returns the HubService object used by this runner.
*
* @return hub service
*/
public HubService getHub() {
return hub_;
}
/**
* Returns the lockfile information associated with this object.
* Only present after {@link #start} has been called.
*
* @return lock info
*/
public LockInfo getLockInfo() {
return lockInfo_;
}
/**
* Returns an HTTP URL at which the lockfile for this hub can be found.
* The first call to this method causes the lockfile to be published
* in this way; subsequent calls return the same value.
*
*
Use this with care; publishing your lockfile means that other people
* can connect to your hub and potentially do disruptive things.
*
* @return lockfile information URL
*/
public URL publishLockfile() throws IOException {
if ( lockUrl_ == null ) {
ByteArrayOutputStream infoStrm = new ByteArrayOutputStream();
writeLockInfo( lockInfo_, infoStrm );
infoStrm.close();
final byte[] infoBuf = infoStrm.toByteArray();
URL url = UtilServer.getInstance().getResourceHandler()
.addResource( "samplock", new ServerResource() {
public long getContentLength() {
return infoBuf.length;
}
public String getContentType() {
return "text/plain";
}
public void writeBody( OutputStream out ) throws IOException {
out.write( infoBuf );
}
} );
// Attempt to replace whatever host name is used by the FQDN,
// for maximal usefulness to off-host clients.
try {
url = new URL( url.getProtocol(),
InetAddress.getLocalHost()
.getCanonicalHostName(),
url.getPort(), url.getFile() );
}
catch ( IOException e ) {
}
lockUrl_ = url;
}
return lockUrl_;
}
/**
* Used to generate the registration password. May be overridden.
*
* @return pasword
*/
public String createSecret() {
return Long.toHexString( random_.nextLong() );
}
/**
* Attempts to determine whether a given lockfile corresponds to a hub
* which is still alive.
*
* @param xClientFactory XML-RPC client factory implementation
* @param lockfile lockfile location
* @return true if the hub described at If the hub mode corresponds to one of the GUI options,
* one of two things will happen. An attempt will be made to install
* an icon in the "system tray"; if this is successful, the attached
* popup menu will provide options for displaying the hub window and
* for shutting it down. If no system tray is available, the hub window
* will be posted directly, and the hub will shut down when this window
* is closed. System tray functionality is only available when running
* under Java 1.6 or later, and when using a suitable display manager.
*
* @param hubMode hub mode
* @param xmlrpc XML-RPC implementation;
* automatically determined if null
* @return running hub
*/
public static HubRunner runHub( HubMode hubMode, XmlRpcKit xmlrpc )
throws IOException {
return runHub( hubMode, xmlrpc, null,
SampUtils
.urlToFile( StandardClientProfile.getLockUrl() ) );
}
/**
* Static method which may be used to start a SAMP hub programmatically,
* with a supplied samp.secret string.
* The returned hub is running ( If the hub mode corresponds to one of the GUI options,
* one of two things will happen. An attempt will be made to install
* an icon in the "system tray"; if this is successful, the attached
* popup menu will provide options for displaying the hub window and
* for shutting it down. If no system tray is available, the hub window
* will be posted directly, and the hub will shut down when this window
* is closed. System tray functionality is only available when running
* under Java 1.6 or later, and when using a suitable display manager.
*
* @param hubMode hub mode
* @param xmlrpc XML-RPC implementation;
* automatically determined if null
* @param secret samp.secret string to be used for hub connection;
* chosen at random if null
* @param lockfile location of lockfile to write,
* or null for lock to be provided by HTTP
* @return running hub
*/
public static HubRunner runHub( HubMode hubMode, XmlRpcKit xmlrpc,
final String secret, File lockfile )
throws IOException {
if ( xmlrpc == null ) {
xmlrpc = XmlRpcKit.getInstance();
}
HubRunner[] hubRunners = new HubRunner[ 1 ];
HubRunner runner =
new HubRunner( xmlrpc.getClientFactory(), xmlrpc.getServerFactory(),
hubMode.createHubService( random_, hubRunners ),
lockfile ) {
public String createSecret() {
return secret == null ? super.createSecret()
: secret;
}
};
hubRunners[ 0 ] = runner;
runner.start();
return runner;
}
/**
* Static method which will attempt to start a hub running in
* an external JVM. The resulting hub can therefore outlast the
* lifetime of the current application.
* Because of the OS interaction required, it's hard to make this
* bulletproof, and it may fail without an exception, but we do our best.
*
* @param hubMode hub mode
* @see #checkExternalHubAvailability
*/
public static void runExternalHub( HubMode hubMode ) throws IOException {
String classpath = System.getProperty( "java.class.path" );
if ( classpath == null || classpath.trim().length() == 0 ) {
throw new IOException( "No classpath available - JNLP context?" );
}
File javaHome = new File( System.getProperty( "java.home" ) );
File javaExec = new File( new File( javaHome, "bin" ), "java" );
String javacmd = ( javaExec.exists() && ! javaExec.isDirectory() )
? javaExec.toString()
: "java";
String[] propagateProps = new String[] {
XmlRpcKit.IMPL_PROP,
UtilServer.PORT_PROP,
SampUtils.LOCALHOST_PROP,
"java.awt.Window.locationByPlatform",
};
List argList = new ArrayList();
argList.add( javacmd );
for ( int ip = 0; ip < propagateProps.length; ip++ ) {
String propName = propagateProps[ ip ];
String propVal = System.getProperty( propName );
if ( propVal != null ) {
argList.add( "-D" + propName + "=" + propVal );
}
}
argList.add( "-classpath" );
argList.add( classpath );
argList.add( HubRunner.class.getName() );
argList.add( "-mode" );
argList.add( hubMode.toString() );
String[] args = (String[]) argList.toArray( new String[ 0 ] );
StringBuffer cmdbuf = new StringBuffer();
for ( int iarg = 0; iarg < args.length; iarg++ ) {
if ( iarg > 0 ) {
cmdbuf.append( ' ' );
}
cmdbuf.append( args[ iarg ] );
}
logger_.info( "Starting external hub" );
logger_.info( cmdbuf.toString() );
execBackground( args );
}
/**
* Attempts to determine whether an external hub can be started using
* {@link #runExternalHub}. If it can be determined that such an
* attempt would fail, this method will throw an exception with
* an informative message. This method succeeding is not a guarantee
* that an external hub can be started successfullly.
* The behaviour of this method is not expected to change over the
* lifetime of a given JVM.
*/
public static void checkExternalHubAvailability() throws IOException {
String classpath = System.getProperty( "java.class.path" );
if ( classpath == null || classpath.trim().length() == 0 ) {
throw new IOException( "No classpath available - JNLP context?" );
}
if ( System.getProperty( "jnlpx.jvm" ) != null ) {
throw new IOException( "Running under WebStart"
+ " - external hub not likely to work" );
}
}
/**
* Executes a command in a separate process, and discards any stdout
* or stderr output generated by it.
* Simply calling lockfile appears
* to be alive and well
*/
private static boolean isHubAlive( SampXmlRpcClientFactory xClientFactory,
File lockfile ) {
LockInfo info;
try {
info = readLockFile( lockfile );
}
catch ( Exception e ) {
logger_.log( Level.WARNING, "Failed to read lockfile", e );
return false;
}
if ( info == null ) {
return false;
}
URL xurl = info.getXmlrpcUrl();
if ( xurl != null ) {
try {
xClientFactory.createClient( xurl )
.callAndWait( "samp.hub.ping", new ArrayList() );
return true;
}
catch ( Exception e ) {
logger_.log( Level.WARNING, "Hub ping method failed", e );
return false;
}
}
else {
logger_.warning( "No XMLRPC URL in lockfile" );
return false;
}
}
/**
* Reads lockinfo from a file.
*
* @param lockFile file
* @return info from file
*/
private static LockInfo readLockFile( File lockFile ) throws IOException {
return LockInfo.readLockFile( new FileInputStream( lockFile ) );
}
/**
* Writes lockfile information to a given output stream.
* The stream is not closed.
*
* @param info lock info to write
* @param out destination stream
*/
private static void writeLockInfo( LockInfo info, OutputStream out )
throws IOException {
LockWriter writer = new LockWriter( out );
writer.writeComment( "SAMP Standard Profile lockfile written "
+ new Date() );
writer.writeComment( "Note contact URL hostname may be "
+ "configured using "
+ SampUtils.LOCALHOST_PROP + " property" );
writer.writeAssignments( info );
out.flush();
}
/**
* Main method. Starts a hub.
* Use "-help" flag for more information.
*
* @param args command-line arguments
*/
public static void main( String[] args ) throws IOException {
int status = runMain( args );
if ( status != 0 ) {
System.exit( status );
}
}
/**
* Does the work for running the {@link #main} method.
* System.exit() is not called from this method.
* Use "-help" flag for more information.
*
* @param args command-line arguments
* @return 0 means success, non-zero means error status
*/
public static int runMain( String[] args ) throws IOException {
StringBuffer ubuf = new StringBuffer();
ubuf.append( "\n Usage:" )
.append( "\n " )
.append( HubRunner.class.getName() )
.append( "\n " )
.append( " [-help]" )
.append( " [-/+verbose]" )
.append( "\n " )
.append( " [-mode " );
HubMode[] modes = HubMode.getAvailableModes();
for ( int im = 0; im < modes.length; im++ ) {
if ( im > 0 ) {
ubuf.append( '|' );
}
ubuf.append( modes[ im ].getName() );
}
ubuf.append( ']' )
.append( " [-secret start has been called).
*
* start has been called).
*
* Runtime.exec can block the process
* until its output is consumed.
*
* @param cmdarray array containing the command to call and its args
*/
private static void execBackground( String[] cmdarray ) throws IOException {
Process process = Runtime.getRuntime().exec( cmdarray );
discardBytes( process.getInputStream() );
discardBytes( process.getErrorStream() );
}
/**
* Ensures that any bytes from a given input stream are discarded.
*
* @param in input stream
*/
private static void discardBytes( final InputStream in ) {
Thread eater = new Thread( "StreamEater" ) {
public void run() {
try {
while ( in.read() >= 0 ) {}
in.close();
}
catch ( IOException e ) {
}
}
};
eater.setDaemon( true );
eater.start();
}
}