package org.astrogrid.samp.web;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.astrogrid.samp.Message;
import org.astrogrid.samp.Metadata;
import org.astrogrid.samp.RegInfo;
import org.astrogrid.samp.Response;
import org.astrogrid.samp.Subscriptions;
import org.astrogrid.samp.client.CallableClient;
import org.astrogrid.samp.client.HubConnection;
import org.astrogrid.samp.client.SampException;
/**
* HubConnection wrapper implementation which intercepts all incoming
* and outgoing communications, scans them for URLs in the payload,
* and notifies a supplied UrlTracker object.
*
* @author Mark Taylor
* @since 22 Jul 2011
*/
class UrlTrackerHubConnection implements HubConnection {
private final HubConnection base_;
private final UrlTracker urlTracker_;
/**
* Constructor.
*
* @param base connection on which this one is based
* @param urlTracker tracker for URL usage
*/
public UrlTrackerHubConnection( HubConnection base,
UrlTracker urlTracker ) {
base_ = base;
urlTracker_ = urlTracker;
}
/**
* Recursively scans a SAMP map for items that look like URLs,
* and notifies the tracker that they are incoming.
* As a convenience the input map is returned.
*
* @param map map to scan
* @return the input map, unchanged
*/
private Map scanIncoming( Map map ) {
URL[] urls = scanForUrls( map );
for ( int iu = 0; iu < urls.length; iu++ ) {
urlTracker_.noteIncomingUrl( urls[ iu ] );
}
return map;
}
/**
* Recursively scans a SAMP map for items that look like URLs,
* and notifies the tracker that they are outgoing.
* As a convenience the input map is returned.
*
* @param map map to scan
* @return the input map, unchanged
*/
private Map scanOutgoing( Map map ) {
URL[] urls = scanForUrls( map );
for ( int iu = 0; iu < urls.length; iu++ ) {
urlTracker_.noteOutgoingUrl( urls[ iu ] );
}
return map;
}
/**
* Recursively scans a map for items that look like URLs and
* returns them as an array.
*
* @param map map to scan
* @return array of URLs found in map
*/
private URL[] scanForUrls( Map map ) {
Collection urlSet = new HashSet();
scanForUrls( map, urlSet );
return (URL[]) urlSet.toArray( new URL[ 0 ] );
}
/**
* Recursively scans a SAMP data item for items that look like URLs
* and appends them into a supplied list.
*
* @param item SAMP data item (String, List or Map)
* @param urlSet list of URL objects to which URLs can be added
*/
private void scanForUrls( Object item, Collection urlSet ) {
if ( item instanceof String ) {
if ( isUrl( (String) item ) ) {
try {
urlSet.add( new URL( (String) item ) );
}
catch ( MalformedURLException e ) {
}
}
}
else if ( item instanceof List ) {
for ( Iterator it = ((List) item).iterator(); it.hasNext(); ) {
scanForUrls( it.next(), urlSet );
}
}
else if ( item instanceof Map ) {
for ( Iterator it = ((Map) item).values().iterator();
it.hasNext(); ) {
scanForUrls( it.next(), urlSet );
}
}
}
/**
* Determines whether a given string is apparently a URL.
*
* @param str string to test
* @return true iff str looks like a URL
*/
private boolean isUrl( String str ) {
if ( str == null || str.indexOf( ":/" ) <= 0 ) {
return false;
}
else {
try {
new URL( str );
return true;
}
catch ( MalformedURLException e ) {
return false;
}
}
}
public void setCallable( CallableClient callable ) throws SampException {
base_.setCallable( new UrlTrackerCallableClient( callable ) );
}
public void notify( String recipientId, Map msg ) throws SampException {
base_.notify( recipientId, scanOutgoing( msg ) );
}
public List notifyAll( Map msg ) throws SampException {
return base_.notifyAll( scanOutgoing( msg ) );
}
public String call( String recipientId, String msgTag, Map msg )
throws SampException {
return base_.call( recipientId, msgTag, scanOutgoing( msg ) );
}
public Map callAll( String msgTag, Map msg ) throws SampException {
return base_.callAll( msgTag, scanOutgoing( msg ) );
}
public Response callAndWait( String recipientId, Map msg, int timeout )
throws SampException {
return (Response)
scanIncoming( base_.callAndWait( recipientId,
scanOutgoing( msg ),
timeout ) );
}
public void reply( String msgId, Map response ) throws SampException {
base_.reply( msgId, scanOutgoing( response ) );
}
public RegInfo getRegInfo() {
return (RegInfo) scanIncoming( base_.getRegInfo() );
}
public void ping() throws SampException {
base_.ping();
}
public void unregister() throws SampException {
base_.unregister();
}
public void declareMetadata( Map meta ) throws SampException {
base_.declareMetadata( scanOutgoing( meta ) );
}
public Metadata getMetadata( String clientId ) throws SampException {
return (Metadata) scanIncoming( base_.getMetadata( clientId ) );
}
public void declareSubscriptions( Map subs ) throws SampException {
base_.declareSubscriptions( scanOutgoing( subs ) );
}
public Subscriptions getSubscriptions( String clientId )
throws SampException {
return (Subscriptions)
scanIncoming( base_.getSubscriptions( clientId ) );
}
public String[] getRegisteredClients() throws SampException {
return base_.getRegisteredClients();
}
public Map getSubscribedClients( String mtype ) throws SampException {
return scanIncoming( base_.getSubscribedClients( mtype ) );
}
/**
* CallableClient wrapper implementation which intercepts
* communications, scans the payloads for URLs, and informs an
* associated UrlTracker.
*/
private class UrlTrackerCallableClient implements CallableClient {
private final CallableClient baseCallable_;
/**
* Constructor.
*
* @param baseCallable object on which this one is based
*/
UrlTrackerCallableClient( CallableClient baseCallable ) {
baseCallable_ = baseCallable;
}
public void receiveCall( String senderId, String msgId, Message msg )
throws Exception {
baseCallable_.receiveCall( senderId, msgId,
(Message) scanIncoming( msg ) );
}
public void receiveNotification( String senderId, Message msg )
throws Exception {
baseCallable_.receiveNotification( senderId,
(Message) scanIncoming( msg ) );
}
public void receiveResponse( String responderId, String msgTag,
Response response )
throws Exception {
baseCallable_.receiveResponse( responderId, msgTag,
(Response)
scanIncoming( response ) );
}
}
}