package org.astrogrid.samp.web;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import org.astrogrid.samp.Metadata;
import org.astrogrid.samp.RegInfo;
import org.astrogrid.samp.Subscriptions;
import org.astrogrid.samp.SampUtils;
import org.astrogrid.samp.client.ClientProfile;
import org.astrogrid.samp.client.HubConnection;
import org.astrogrid.samp.client.SampException;
import org.astrogrid.samp.httpd.HttpServer;
import org.astrogrid.samp.httpd.URLMapperHandler;
import org.astrogrid.samp.hub.KeyGenerator;
import org.astrogrid.samp.xmlrpc.ActorHandler;
/**
* SampXmlRpcHandler implementation which passes Web Profile-type XML-RPC calls
* to a hub connection factory to provide a Web Profile hub server.
*
* @author Mark Taylor
* @since 2 Feb 2011
*/
public class WebHubXmlRpcHandler extends ActorHandler {
private final WebHubActorImpl impl_;
private static final Logger logger_ =
Logger.getLogger( WebHubXmlRpcHandler.class.getName() );
/**
* Constructor.
*
* @param profile hub connection factory
* @param auth client authorizer
* @param keyGen key generator for private keys
* @param baseUrl base URL of HTTP server, used for URL translation
* @param urlTracker tracks URLs in messages to restrict use in URL
* translation service for security reasons; may be null for
* no restrictions
*/
public WebHubXmlRpcHandler( ClientProfile profile, ClientAuthorizer auth,
KeyGenerator keyGen, URL baseUrl,
UrlTracker urlTracker ) {
super( WebClientProfile.WEBSAMP_HUB_PREFIX, WebHubActor.class,
new WebHubActorImpl( profile, auth, keyGen, baseUrl,
urlTracker ) );
impl_ = (WebHubActorImpl) getActor();
}
public Object handleCall( String fqName, List params, Object reqObj )
throws Exception {
String regMethod = WebClientProfile.WEBSAMP_HUB_PREFIX + "register";
if ( regMethod.equals( fqName ) &&
reqObj instanceof HttpServer.Request ) {
HttpServer.Request req = (HttpServer.Request) reqObj;
final Map securityMap;
if ( params.size() == 1 && params.get( 0 ) instanceof Map ) {
securityMap = (Map) params.get( 0 );
}
else if ( params.size() == 1 &&
params.get( 0 ) instanceof String ) {
securityMap = new HashMap();
securityMap.put( Metadata.NAME_KEY, (String) params.get( 0 ) );
logger_.info( "Deprecated register call signature "
+ "(arg is string appName not map security-info)" );
}
else {
throw new IllegalArgumentException( "Bad args for " + regMethod
+ "(map)" );
}
Map result = impl_.register( req, securityMap );
assert result != null;
return result;
}
else {
return super.handleCall( fqName, params, reqObj );
}
}
/**
* Returns a handler suitable for performing URL translations on behalf
* of sandboxed clients as required by the Web Profile.
*
* @return url translation handler
*/
public HttpServer.Handler getUrlTranslationHandler() {
return impl_.getUrlTranslationHandler();
}
protected Object invokeMethod( Method method, Object obj, Object[] args )
throws IllegalAccessException, InvocationTargetException {
return method.invoke( obj, args );
}
/**
* WebHubActor implementation.
*/
private static class WebHubActorImpl implements WebHubActor {
private final ClientProfile profile_;
private final ClientAuthorizer auth_;
private final KeyGenerator keyGen_;
private final Map regMap_;
private final URLTranslationHandler urlTranslator_;
private final URL baseUrl_;
private final UrlTracker urlTracker_;
/**
* Constructor.
*
* @param profile hub connection factory
* @param auth client authorizer
* @param keyGen key generator for private keys
* @param baseUrl HTTP server base URL
* @param urlTracker controls access to translated URLs,
* may be null for no control
*/
public WebHubActorImpl( ClientProfile profile, ClientAuthorizer auth,
KeyGenerator keyGen, URL baseUrl,
UrlTracker urlTracker ) {
profile_ = profile;
auth_ = auth;
keyGen_ = keyGen;
baseUrl_ = baseUrl;
urlTracker_ = urlTracker;
regMap_ = Collections.synchronizedMap( new HashMap() );
urlTranslator_ =
new URLTranslationHandler( "/proxied/", regMap_.keySet(),
urlTracker );
}
/**
* Returns a handler suitable for performing URL translations on behalf
* of sandboxed clients as required by the Web Profile.
*
* @return url translation handler
*/
public HttpServer.Handler getUrlTranslationHandler() {
return urlTranslator_;
}
/**
* Attempt client registration. An exception is thrown if registration
* fails for any reason.
*
* @param request HTTP request from applicant
* @param securityMap map of required security information
* supplied by applicant
* @return registration information if registration is successful
*/
public RegInfo register( HttpServer.Request request, Map securityMap )
throws SampException {
if ( profile_.isHubRunning() ) {
auth_.authorize( request, securityMap );
HubConnection connection = profile_.register();
if ( connection != null ) {
if ( urlTracker_ != null ) {
connection = new UrlTrackerHubConnection( connection,
urlTracker_ );
}
String clientKey = keyGen_.next();
regMap_.put( clientKey, new Registration( connection ) );
String urlTrans = baseUrl_
+ urlTranslator_
.getTranslationBasePath( clientKey );
RegInfo regInfo = new RegInfo( connection.getRegInfo() );
regInfo.put( RegInfo.PRIVATEKEY_KEY, clientKey );
regInfo.put( WebClientProfile.URLTRANS_KEY, urlTrans );
return regInfo;
}
else {
throw new SampException( "Hub is not running" );
}
}
else {
throw new SampException( "Hub not running" );
}
}
public void unregister( String clientKey ) throws SampException {
HubConnection connection = getConnection( clientKey );
regMap_.remove( clientKey );
connection.unregister();
}
public void allowReverseCallbacks( String clientKey, String allow )
throws SampException {
boolean isAllowed = SampUtils.decodeBoolean( allow );
Registration reg = getRegistration( clientKey );
synchronized ( reg ) {
if ( isAllowed == ( reg.callable_ != null ) ) {
return;
}
else if ( isAllowed ) {
WebCallableClient callable = new WebCallableClient();
reg.connection_.setCallable( callable );
reg.callable_ = callable;
}
else {
reg.connection_.setCallable( null );
reg.callable_.endCallbacks();
reg.callable_ = null;
}
assert isAllowed == ( reg.callable_ != null );
}
}
public List pullCallbacks( String clientKey, String timeout )
throws SampException {
WebCallableClient callable = getRegistration( clientKey ).callable_;
if ( callable != null ) {
return callable
.pullCallbacks( SampUtils.decodeInt( timeout ) );
}
else {
throw new SampException( "Client is not callable (first invoke"
+ " allowReverseCallbacks)" );
}
}
public void declareMetadata( String clientKey, Map meta )
throws SampException {
getConnection( clientKey ).declareMetadata( meta );
}
public Map getMetadata( String clientKey, String clientId )
throws SampException {
return getConnection( clientKey ).getMetadata( clientId );
}
public void declareSubscriptions( String clientKey, Map subs )
throws SampException {
getRegistration( clientKey ).subs_ =
new Subscriptions( subs == null ? new HashMap() : subs );
getConnection( clientKey ).declareSubscriptions( subs );
}
public Map getSubscriptions( String clientKey, String clientId )
throws SampException {
return getConnection( clientKey ).getSubscriptions( clientId );
}
public List getRegisteredClients( String clientKey )
throws SampException {
return Arrays.asList( getConnection( clientKey )
.getRegisteredClients() );
}
public Map getSubscribedClients( String clientKey, String mtype )
throws SampException {
return getConnection( clientKey ).getSubscribedClients( mtype );
}
public void notify( String clientKey, String recipientId, Map msg )
throws SampException {
getConnection( clientKey ).notify( recipientId, msg );
}
public List notifyAll( String clientKey, Map msg )
throws SampException {
return getConnection( clientKey ).notifyAll( msg );
}
public String call( String clientKey, String recipientId, String msgTag,
Map msg )
throws SampException {
return getConnection( clientKey ).call( recipientId, msgTag, msg );
}
public Map callAll( String clientKey, String msgTag, Map msg )
throws SampException {
return getConnection( clientKey ).callAll( msgTag, msg );
}
public Map callAndWait( String clientKey, String recipientId, Map msg,
String timeout )
throws SampException {
return getConnection( clientKey )
.callAndWait( recipientId, msg,
SampUtils.decodeInt( timeout ) );
}
public void reply( String clientKey, String msgId, Map response )
throws SampException {
getConnection( clientKey ).reply( msgId, response );
}
public void ping() {
if ( ! profile_.isHubRunning() ) {
throw new RuntimeException( "No hub running" );
}
}
public void ping( String clientKey ) {
ping();
}
/**
* Returns the registration object associated with a given private key.
*
* @param privateKey private key string known by client and hub
* to identify the connection
* @return registration object for client with key
* privateKey
* @throws SampException if no client is known with that private key
*/
private Registration getRegistration( String privateKey )
throws SampException {
Registration reg = (Registration) regMap_.get( privateKey );
if ( reg == null ) {
throw new SampException( "Unknown client key" );
}
else {
return reg;
}
}
/**
* Returns the connection object associated with a given private key.
*
* @param privateKey private key string known by client and hub
* to identify the connection
* @return connection object for client with key
* privateKey
* @throws SampException if no client is known with that private key
*/
private HubConnection getConnection( String privateKey )
throws SampException {
return getRegistration( privateKey ).connection_;
}
}
/**
* HTTP handler which provides URL translation services for sandboxed
* clients.
*/
private static class URLTranslationHandler implements HttpServer.Handler {
private final String basePath_;
private final Set keySet_;
private final UrlTracker urlTracker_;
/**
* Constructor.
*
* @param basePath base path for HTTP server
* @param keySet set of strings which contains keys for all
* currently registered clients
* @param urlTracker controls access to translated URLs,
* may be null for no control
*/
public URLTranslationHandler( String basePath, Set keySet,
UrlTracker urlTracker ) {
if ( ! basePath.startsWith( "/" ) ) {
basePath = "/" + basePath;
}
if ( ! basePath.endsWith( "/" ) ) {
basePath = basePath + "/";
}
basePath_ = basePath;
keySet_ = keySet;
urlTracker_ = urlTracker;
}
/**
* Returns the translation base path that can be used by a client
* with a given private key.
*
* @param privateKey client private key
* @return URL translation base path that can be used by a
* registered client with the given private key
*/
public String getTranslationBasePath( String privateKey ) {
return basePath_ + privateKey + "?";
}
public HttpServer.Response serveRequest( HttpServer.Request request ) {
// Ignore requests outside this handler's domain.
String path = request.getUrl();
if ( ! path.startsWith( basePath_ ) ) {
return null;
}
// Ensure the URL has a query part.
String relPath = path.substring( basePath_.length() );
int qIndex = relPath.indexOf( '?' );
if ( qIndex < 0 ) {
return HttpServer.createErrorResponse( 404, "Not Found" );
}
// Ensure a valid key for authorization is present; this makes
// sure that only registered clients can use this service.
String authKey = relPath.substring( 0, qIndex );
if ( ! keySet_.contains( authKey ) ) {
return HttpServer.createErrorResponse( 403, "Forbidden" );
}
// Extract the URL whose translation is being requested.
assert path.substring( 0, path.indexOf( '?' ) + 1 )
.equals( getTranslationBasePath( authKey ) );
String targetString;
try {
targetString =
SampUtils.uriDecode( relPath.substring( qIndex + 1 ) );
}
catch ( RuntimeException e ) {
return HttpServer.createErrorResponse( 400, "Bad Request" );
}
URL targetUrl;
try {
targetUrl = new URL( targetString );
}
catch ( MalformedURLException e ) {
return HttpServer.createErrorResponse( 400, "Bad Request" );
}
// Check permissions.
if ( urlTracker_ != null &&
! urlTracker_.isUrlPermitted( targetUrl ) ) {
return HttpServer.createErrorResponse( 403, "Forbidden" );
}
// Perform the translation and return the result.
return URLMapperHandler.mapUrlResponse( request.getMethod(),
targetUrl );
}
}
/**
* Utility class to aggregate information about a registered client.
*/
private static class Registration {
final HubConnection connection_;
WebCallableClient callable_;
Subscriptions subs_;
/**
* Constructor.
*
* @param connection hub connection
*/
Registration( HubConnection connection ) {
connection_ = connection;
}
}
}