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.OutputStream;
import java.net.InetAddress;
import java.net.URL;
import java.util.ArrayList;
import java.util.Date;
import java.util.Random;
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.httpd.ServerResource;
import org.astrogrid.samp.httpd.UtilServer;
import org.astrogrid.samp.hub.HubProfile;
import org.astrogrid.samp.hub.KeyGenerator;
import org.astrogrid.samp.hub.LockWriter;
import org.astrogrid.samp.hub.MessageRestriction;
/**
* HubProfile implementation for the SAMP Standard Profile.
*
* @author Mark Taylor
* @since 31 Jan 2011
*/
public class StandardHubProfile implements HubProfile {
private final SampXmlRpcClientFactory xClientFactory_;
private final SampXmlRpcServerFactory xServerFactory_;
private final File lockfile_;
private final String secret_;
private URL lockUrl_;
private SampXmlRpcServer server_;
private volatile HubXmlRpcHandler hubHandler_;
private LockInfo lockInfo_;
private static final Logger logger_ =
Logger.getLogger( StandardHubProfile.class.getName() );
private static final Random random_ = KeyGenerator.createRandom();
/**
* Constructs a hub profile with given configuration information.
* 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 lockfile location to use for hub lockfile, or null
* @param secret value for samp.secret lockfile key
*/
public StandardHubProfile( SampXmlRpcClientFactory xClientFactory,
SampXmlRpcServerFactory xServerFactory,
File lockfile, String secret ) {
xClientFactory_ = xClientFactory;
xServerFactory_ = xServerFactory;
lockfile_ = lockfile;
secret_ = secret;
}
/**
* Constructs a hub profile with default configuration.
*/
public StandardHubProfile() throws IOException {
this( XmlRpcKit.getInstance().getClientFactory(),
XmlRpcKit.getInstance().getServerFactory(),
SampUtils.urlToFile( StandardClientProfile.getLockUrl() ),
createSecret() );
}
public String getProfileName() {
return "Standard";
}
public MessageRestriction getMessageRestriction() {
return null;
}
public synchronized void start( ClientProfile profile ) throws IOException {
// Check state.
if ( isRunning() ) {
logger_.info( "Profile already started" );
return;
}
// Check for running hub. If there is a running hub, bail out.
// If there is a lockfile but apparently no running hub,
// continue preparations to start; the hub reference by the lockfile
// may either be moribund or in the process of starting up.
// To deal with the latter case, make all our preparations to give
// it more time to get going before preempting it.
if ( lockfile_ != null && lockfile_.exists() ) {
if ( isHubAlive( xClientFactory_, lockfile_ ) ) {
throw new IOException( "A hub is already running" );
}
}
// 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 );
}
hubHandler_ =
new HubXmlRpcHandler( xClientFactory_, profile, secret_,
new KeyGenerator( "k:", 16, random_ ) );
server_.addHandler( hubHandler_ );
// Prepare lockfile information.
lockInfo_ = new LockInfo( secret_, server_.getEndpoint().toString() );
lockInfo_.put( "hub.impl", profile.getClass().getName() );
lockInfo_.put( "profile.impl", this.getClass().getName() );
lockInfo_.put( "profile.start.date", new Date().toString() );
// Write lockfile information to file if required.
if ( lockfile_ != null ) {
// If the lockfile already exists, wait a little while in case
// a hub is in the process of waking up. If it's still not
// present, overwrite the lockfile with a warning.
if ( ! lockfile_.createNewFile() ) {
try {
Thread.sleep( 500 );
}
catch ( InterruptedException e ) {
}
if ( isHubAlive( xClientFactory_, lockfile_ ) ) {
server_.removeHandler( hubHandler_ );
hubHandler_ = null;
throw new IOException( "A hub is already running" );
}
else {
logger_.warning( "Overwriting " + lockfile_ + " lockfile "
+ "for apparently dead hub" );
}
}
FileOutputStream out = new FileOutputStream( lockfile_ );
try {
writeLockInfo( lockInfo_, out );
logger_.info( "Wrote new lockfile " + lockfile_ );
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 );
}
}
}
// If the lockfile is not the default one, write a message through
// the logging system.
URL lockfileUrl = lockfile_ == null
? publishLockfile()
: SampUtils.fileToUrl( lockfile_ );
boolean isDflt = StandardClientProfile.getDefaultLockUrl().toString()
.equals( lockfileUrl.toString() );
String hubassign = DefaultClientProfile.HUBLOC_ENV + "="
+ StandardClientProfile.STDPROFILE_HUB_PREFIX
+ lockfileUrl;
logger_.log( isDflt ? Level.INFO : Level.WARNING, hubassign );
}
public synchronized boolean isRunning() {
return hubHandler_ != null;
}
public synchronized void stop() {
if ( ! isRunning() ) {
logger_.info( "Profile already stopped" );
return;
}
// Delete the lockfile if it exists and if it is the one originally
// written by this runner.
if ( lockInfo_ != null && 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;
}
// Remove the hub XML-RPC handler from the server.
if ( hubHandler_ != null && server_ != null ) {
server_.removeHandler( hubHandler_ );
}
server_ = null;
hubHandler_ = null;
lockInfo_ = null;
}
/**
* Returns the lockfile information associated with this object.
* Only present when running.
*
* @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_;
}
/**
* Returns a string suitable for use as a Standard Profile Secret.
*
* @return new secret
*/
public static synchronized 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 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();
}
}