package org.astrogrid.samp.xmlrpc; import java.io.File; import java.io.IOException; import java.net.MalformedURLException; import java.net.URL; import java.util.ArrayList; import java.util.logging.Logger; import org.astrogrid.samp.DataException; import org.astrogrid.samp.Platform; 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; /** * Standard Profile implementation of ClientProfile. * It is normally appropriate to use one of the static methods * to obtain an instance based on a particular XML-RPC implementation. * * @author Mark Taylor * @since 15 Jul 2008 */ public class StandardClientProfile implements ClientProfile { private final SampXmlRpcClientFactory xClientFactory_; private final SampXmlRpcServerFactory xServerFactory_; private static StandardClientProfile defaultInstance_; private static URL dfltLockUrl_; private static URL lockUrl_; private static final Logger logger_ = Logger.getLogger( StandardClientProfile.class.getName() ); /** Filename used for lockfile in home directory by default ({@value}). */ public static final String LOCKFILE_NAME = ".samp"; /** Prefix in SAMP_HUB value indicating lockfile URL ({@value}). */ public static final String STDPROFILE_HUB_PREFIX = "std-lockurl:"; /** * Constructs a profile given client and server factory implementations. * * @param xClientFactory XML-RPC client factory implementation * @param xServerFactory XML-RPC server factory implementation */ public StandardClientProfile( SampXmlRpcClientFactory xClientFactory, SampXmlRpcServerFactory xServerFactory ) { xClientFactory_ = xClientFactory; xServerFactory_ = xServerFactory; } /** * Constructs a profile given an XmlRpcKit object. * * @param xmlrpc XML-RPC implementation */ public StandardClientProfile( XmlRpcKit xmlrpc ) { this( xmlrpc.getClientFactory(), xmlrpc.getServerFactory() ); } public boolean isHubRunning() { try { LockInfo lockInfo = getLockInfo(); if ( lockInfo == null ) { return false; } URL xurl = lockInfo.getXmlrpcUrl(); if ( xurl == null ) { return false; } SampXmlRpcClient xClient = xClientFactory_.createClient( xurl ); xClient.callAndWait( "samp.hub.ping", new ArrayList() ); return true; } catch ( IOException e ) { return false; } } public HubConnection register() throws SampException { LockInfo lockInfo; try { lockInfo = getLockInfo(); } catch ( SampException e ) { throw (SampException) e; } catch ( IOException e ) { throw new SampException( "Error reading lockfile", e ); } if ( lockInfo == null ) { return null; } else { try { lockInfo.check(); } catch ( DataException e ) { String msg = "Incomplete/broken lock file"; try { File lockFile = SampUtils.urlToFile( getLockUrl() ); if ( lockFile != null ) { msg += " - try deleting " + lockFile; } } catch ( IOException e2 ) { // never mind } throw new SampException( msg, e ); } SampXmlRpcClient xClient; URL xurl = lockInfo.getXmlrpcUrl(); try { xClient = xClientFactory_.createClient( xurl ); } catch ( IOException e ) { throw new SampException( "Can't connect to " + xurl, e ); } return new StandardHubConnection( xClient, xServerFactory_, lockInfo.getSecret() ); } } /** * Returns the LockInfo which indicates how to locate the hub. * If no lockfile exists (probably becuause no appropriate hub * is running), null is returned. * The default implementation returns * LockInfo.readLockFile(getLockUrl()); * it may be overridden to provide a non-standard client profiles. * * @return hub location information * @throws IOException if the lockfile exists but cannot be read for * some reason */ public LockInfo getLockInfo() throws IOException { return LockInfo.readLockFile( getLockUrl() ); } /** * Returns the location of the Standard Profile lockfile. * By default this is the file .samp in the user's "home" * directory, unless overridden by a value of the SAMP_HUB environment * variable starting with "std-lockurl". * * @return lockfile URL */ public static URL getLockUrl() throws IOException { if ( lockUrl_ == null ) { String hublocEnv = DefaultClientProfile.HUBLOC_ENV; String hubloc = Platform.getPlatform().getEnv( hublocEnv ); final URL lockUrl; if ( hubloc != null && hubloc.startsWith( STDPROFILE_HUB_PREFIX ) ) { lockUrl = new URL( hubloc.substring( STDPROFILE_HUB_PREFIX .length() ) ); logger_.info( "Lockfile as set by env var: " + hublocEnv + "=" + hubloc ); } else if ( hubloc != null && hubloc.trim().length() > 0 ) { logger_.warning( "Ignoring non-Standard " + hublocEnv + "=" + hubloc ); lockUrl = getDefaultLockUrl(); } else { lockUrl = getDefaultLockUrl(); logger_.info( "Using default Standard Profile lockfile: " + SampUtils.urlToFile( lockUrl ) ); } lockUrl_ = lockUrl; } return lockUrl_; } /** * Returns the lockfile URL which will be used in absence of any * SAMP_HUB environment variable. * * @return URL for file .samp in user's home directory */ public static URL getDefaultLockUrl() throws IOException { if ( dfltLockUrl_ == null ) { dfltLockUrl_ = SampUtils.fileToUrl( new File( Platform.getPlatform() .getHomeDirectory(), LOCKFILE_NAME ) ); } return dfltLockUrl_; } /** * Returns an instance based on the default XML-RPC implementation. * This can be configured using system properties. * * @see XmlRpcKit#getInstance * @see org.astrogrid.samp.client.DefaultClientProfile#getProfile * @return a client profile instance */ public static StandardClientProfile getInstance() { if ( defaultInstance_ == null ) { XmlRpcKit xmlrpc = XmlRpcKit.getInstance(); defaultInstance_ = new StandardClientProfile( xmlrpc.getClientFactory(), xmlrpc.getServerFactory() ); } return defaultInstance_; } }