package org.astrogrid.samp.httpd; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.BindException; import java.net.MalformedURLException; import java.net.ServerSocket; import java.net.URL; import java.util.HashSet; import java.util.Set; import java.util.logging.Logger; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * Utility class for use with HttpServer. * *
This class performs two functions. Firstly it provides a static * {@link #getInstance} method which allows its use in a singleton-like way. * The constructor is public, so singleton use is not enforced, but if * you need a server but don't need exclusive control over it, obtaining * one in this way will ensure that you don't start a new server * (which requires a new socket and other resources) if a suitable one * is already available. * *
Secondly, it provides some utility methods,
* {@link #exportResource} and {@link #exportFile},
* useful for turning files or classpath resources into
* publicly viewable URLs, which is sometimes useful within a SAMP
* context (for instance when providing an Icon URL in metadata).
*
* @author Mark Taylor
* @since 22 Jul 2009
*/
public class UtilServer {
private final HttpServer server_;
private final Set baseSet_;
private MultiURLMapperHandler mapperHandler_;
private ResourceHandler resourceHandler_;
/**
* System Property key giving a preferred port number for the server.
* If unset, or 0, or the chosen port is occupied, a system-chosen
* value will be used.
* The property name is {@value}.
*/
public static final String PORT_PROP = "jsamp.server.port";
/** Buffer size for copy data from input to output stream. */
private static int BUFSIZ = 16 * 1024;
/** Default instance of this class. */
private static UtilServer instance_;
private static final Pattern SLASH_REGEX =
Pattern.compile( "(/*)(.*?)(/*)" );
private static final Pattern NUMBER_REGEX =
Pattern.compile( "(.*?)([0-9]+)" );
private static final Logger logger_ =
Logger.getLogger( UtilServer.class.getName() );
/**
* Constructor.
* Note, it may be more appropriate to use the {@link #getInstance} method.
*
* @param server HTTP server providing base services
*/
public UtilServer( HttpServer server ) throws IOException {
server_ = server;
baseSet_ = new HashSet();
}
/**
* Returns the HttpServer associated with this object.
*
* @return a running server instance
*/
public HttpServer getServer() {
return server_;
}
/**
* Returns a handler for mapping local to external URLs associated with
* this server.
*
* @return url mapping handler
*/
public synchronized MultiURLMapperHandler getMapperHandler() {
if ( mapperHandler_ == null ) {
try {
mapperHandler_ =
new MultiURLMapperHandler( server_,
getBasePath( "/export" ) );
}
catch ( MalformedURLException e ) {
throw (AssertionError) new AssertionError().initCause( e );
}
server_.addHandler( mapperHandler_ );
}
return mapperHandler_;
}
/**
* Returns a handler for general purpose resource serving associated with
* this server.
*
* @return resource serving handler
*/
public synchronized ResourceHandler getResourceHandler() {
if ( resourceHandler_ == null ) {
resourceHandler_ =
new ResourceHandler( server_, getBasePath( "/docs" ) );
server_.addHandler( resourceHandler_ );
}
return resourceHandler_;
}
/**
* Exposes a resource from a given URL as a publicly visible URL.
* This is typically used if the given localUrl is
* only visible locally, for instance on this JVM's classpath.
*
* @param localUrl URL visible at least within this JVM
* @return URL for external reference to the resource
*/
public URL exportResource( URL localUrl ) throws IOException {
return getMapperHandler().addLocalUrl( localUrl );
}
/**
* Exposes a resource from the JVM's classpath as a publicly visible URL.
* The classloader of this class is used, which may not be the right one
* for the resource in question.
* For that reason, this utility method is deprecated
* in favour of the overloaded method that takes a URL.
*
* @param resource fully qualified path to a resource in the current
* classpath; separators are "/" characters
* @return URL for external reference to the resource
* @deprecated since after 1.3.5,
* use instead {@link #exportResource(java.net.URL)}
*/
public URL exportResource( String resource ) throws IOException {
URL localUrl = UtilServer.class.getResource( resource );
if ( localUrl != null ) {
return getMapperHandler().addLocalUrl( localUrl );
}
else {
throw new IOException( "Not found on classpath: " + resource );
}
}
/**
* Exposes a file in the local filesystem as a publicly visible URL.
*
* @param file a file on a filesystem visible from the local host
* @return URL for external reference to the resource
*/
public URL exportFile( File file ) throws IOException {
if ( file.exists() ) {
return getMapperHandler().addLocalUrl( file.toURL() );
}
else {
throw new FileNotFoundException( "No such file: " + file );
}
}
/**
* May be used to return a unique base path for use with this class's
* HttpServer. If all users of this server use this method
* to get base paths for use with different handlers, nameclash
* avoidance is guaranteed.
*
* @param txt basic text for base path
* @return base path; will likely bear some resemblance to
* txt, but may be adjusted to ensure uniqueness
*/
public synchronized String getBasePath( String txt ) {
Matcher slashMatcher = SLASH_REGEX.matcher( txt );
String pre;
String body;
String post;
if ( slashMatcher.matches() ) {
pre = slashMatcher.group( 1 );
body = slashMatcher.group( 2 );
post = slashMatcher.group( 3 );
}
else {
assert false;
pre = "";
body = txt;
post = "";
}
if ( baseSet_.contains( body ) ) {
String stem = body;
int i = 1;
while ( baseSet_.contains( stem + "-" + i ) ) {
i++;
}
body = stem + "-" + i;
}
baseSet_.add( body );
return pre + body + post;
}
/**
* Returns the default instance of this class.
* The first time this method is called a new daemon UtilServer
* is (lazily) created, and started. Any subsequent calls will
* return the same object, unless {@link #getInstance} is called.
*
* @return default instance of this class
*/
public static synchronized UtilServer getInstance() throws IOException {
if ( instance_ == null ) {
ServerSocket sock = null;
String sPort = System.getProperty( PORT_PROP );
if ( sPort != null && sPort.length() > 0 ) {
int port = Integer.parseInt( sPort );
try {
sock = new ServerSocket( port );
}
catch ( BindException e ) {
logger_.warning( "Can't open socket on port " + port
+ " (" + e + ") - use another one" );
}
}
if ( sock == null ) {
sock = new ServerSocket( 0 );
}
HttpServer server = new HttpServer( sock );
server.setDaemon( true );
server.start();
instance_ = new UtilServer( server );
}
return instance_;
}
/**
* Sets the default instance of this class.
*
* @param server default instance to be returned by {@link #getInstance}
*/
public static synchronized void setInstance( UtilServer server ) {
instance_ = server;
}
/**
* Copies the content of an input stream to an output stream.
* The input stream is always closed on exit; the output stream is not.
*
* @param in input stream
* @param out output stream
*/
public static void copy( InputStream in, OutputStream out )
throws IOException {
byte[] buf = new byte[ BUFSIZ ];
try {
for ( int nb; ( nb = in.read( buf ) ) >= 0; ) {
out.write( buf, 0, nb );
}
out.flush();
}
finally {
in.close();
}
}
}