package org.astrogrid.samp.test; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import org.astrogrid.samp.Response; import org.astrogrid.samp.client.CallableClient; import org.astrogrid.samp.client.HubConnection; import org.astrogrid.samp.client.SampException; /** * Partial implementation of {@link CallableClient} which handles the * receiveReply method. * This takes care of matching up replies with calls and is intended for * use with test classes. Some assertions are made within this class * to check that replies match with messages sent. Call-type messages * must be sent using this object's call and callAll * methods, rather than directly on the HubConnection, * to ensure that the internal state stays correct. * * @author Mark Taylor * @since 18 Jul 2008 */ abstract class ReplyCollector implements CallableClient { private final HubConnection connection_; private final Set sentSet_; private final Map replyMap_; private boolean allowTagReuse_; /** * Constructor. * * @param connection hub connection * @param allowTagReuse if true clients may reuse tags; * if false any such attempt generates an exception */ public ReplyCollector( HubConnection connection ) { connection_ = connection; sentSet_ = Collections.synchronizedSet( new HashSet() ); replyMap_ = Collections.synchronizedMap( new HashMap() ); } /** * Determines whether clients are permitted to reuse tags for different * messages. If true, any such attempt generates an exception. * * @param allow whether to allow tag reuse */ public void setAllowTagReuse( boolean allow ) { allowTagReuse_ = allow; } /** * Performs a call method on this collector's hub connection. * Additional internal state is updated. * Although it is legal as far as SAMP goes, the msgTag * must not be one which was used earlier for the same recipient. * * @param recipientId public-id of client to receive message * @param msgTag arbitrary string tagging this message for caller's * benefit * @param msg {@link org.astrogrid.samp.Message}-like map * @return message ID */ public String call( String recipientId, String msgTag, Map msg ) throws SampException { Object key = createKey( recipientId, msgTag ); if ( ! allowTagReuse_ && sentSet_.contains( key ) ) { throw new IllegalArgumentException( "Key " + key + " reused" ); } sentSet_.add( key ); return connection_.call( recipientId, msgTag, msg ); } /** * Performs a callAll method on this collector's * hub connection. * Additional internal state is updated. * Although it is legal as far as SAMP goes, the msgTag * must not be one which was used for an earlier broadcast. * * @param msgTag arbitrary string tagging this message for caller's * benefit * @param msg {@link org.astrogrid.samp.Message}-like map * @return message ID */ public Map callAll( String msgTag, Map msg ) throws SampException { Object key = createKey( null, msgTag ); if ( ! allowTagReuse_ && sentSet_.contains( key ) ) { throw new IllegalArgumentException( "Key " + key + " reused" ); } sentSet_.add( key ); return connection_.callAll( msgTag, msg ); } public void receiveResponse( String responderId, String msgTag, Response response ) { Object key = createKey( responderId, msgTag ); Object result; try { if ( ! allowTagReuse_ && replyMap_.containsKey( key ) ) { throw new TestException( "Response for " + key + " already received" ); } else if ( ! sentSet_.contains( key ) && ! sentSet_.contains( createKey( null, msgTag ) ) ) { throw new TestException( "Message " + key + " never sent" ); } result = response; } catch ( TestException e ) { result = e; } synchronized ( replyMap_ ) { if ( ! replyMap_.containsKey( key ) ) { replyMap_.put( key, new ArrayList() ); } ((List) replyMap_.get( key )).add( result ); replyMap_.notifyAll(); } } /** * Returns the total number of unretrieved replies so far collected by * this object. * * @return reply count */ public int getReplyCount() { int count = 0; synchronized ( replyMap_ ) { for ( Iterator it = replyMap_.values().iterator(); it.hasNext(); ) { count += ((List) it.next()).size(); } } return count; } /** * Waits for a reply to a message sent earlier * using call or callAll. * Blocks until such a response is received. * * @param responderId client ID of client providing response * @param msgTag tag which was used to send the message * @return response */ public Response waitForReply( String responderId, String msgTag ) { Object key = createKey( responderId, msgTag ); try { synchronized ( replyMap_ ) { while ( ! replyMap_.containsKey( key ) || ((List) replyMap_.get( key )).isEmpty() ) { replyMap_.wait(); } } } catch ( InterruptedException e ) { throw new Error( "Interrupted", e ); } return getReply( responderId, msgTag ); } /** * Gets the reply to a message sent earlier * using call or callAll. * Does not block; if no such response has been received so far, * returns null. * * @param responderId client ID of client providing response * @param msgTag tag which was used to send the message * @return response */ public Response getReply( String responderId, String msgTag ) { Object key = createKey( responderId, msgTag ); synchronized ( replyMap_ ) { List list = (List) replyMap_.get( key ); Object result = list == null || list.isEmpty() ? null : list.remove( 0 ); if ( result == null ) { return null; } else if ( result instanceof Response ) { return (Response) result; } else if ( result instanceof Throwable ) { throw new TestException( (Throwable) result ); } else { throw new AssertionError(); } } } /** * Returns an opaque object suitable for use as a map key * based on a recipient ID and message tag. * * @param recipientId recipient ID * @param msgTag message tag */ private static Object createKey( String recipientId, String msgTag ) { return Arrays.asList( new String[] { recipientId, msgTag } ); } }