package org.astrogrid.samp.test;
import java.io.IOException;
import java.net.URL;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import org.astrogrid.samp.Client;
import org.astrogrid.samp.ErrInfo;
import org.astrogrid.samp.Message;
import org.astrogrid.samp.Metadata;
import org.astrogrid.samp.RegInfo;
import org.astrogrid.samp.Response;
import org.astrogrid.samp.SampUtils;
import org.astrogrid.samp.Subscriptions;
import org.astrogrid.samp.client.CallableClient;
import org.astrogrid.samp.client.ClientProfile;
import org.astrogrid.samp.client.DefaultClientProfile;
import org.astrogrid.samp.client.HubConnection;
import org.astrogrid.samp.client.SampException;
import org.astrogrid.samp.gui.HubMonitor;
import org.astrogrid.samp.xmlrpc.LockInfo;
import org.astrogrid.samp.xmlrpc.StandardClientProfile;
/**
* Tester for a running hub.
* Attempts to test as much of the SAMP standard as possible for an existing
* hub implementation.
*
* @author Mark Taylor
* @since 18 Jul 2008
*/
public class HubTester extends Tester {
private final ClientProfile profile_;
private final String hubId_;
private final Client[] ignoreClients_;
private final Set selfIds_;
private final Set privateKeys_;
private final ClientWatcher clientWatcher_;
private final Random random_ = new Random( 233333L );
private static final String WAITMILLIS_KEY = "test.wait";
private static final String MSGIDQUERY_KEY = "test.msgid";
private static final String ECHO_MTYPE = "test.echo";
private static final String PING_MTYPE = "samp.app.ping";
private static final String FAIL_MTYPE = "test.fail";
private static final String REGISTER_MTYPE = "samp.hub.event.register";
private static final String UNREGISTER_MTYPE = "samp.hub.event.unregister";
private static final String METADATA_MTYPE = "samp.hub.event.metadata";
private static final String SUBSCRIPTIONS_MTYPE =
"samp.hub.event.subscriptions";
private static final String ERROR_KEY = "test.error";
private static final char[] ALPHA_CHARS = createAlphaCharacters();
private static final char[] GENERAL_CHARS = createGeneralCharacters();
private static Logger logger_ =
Logger.getLogger( HubTester.class.getName() );
/**
* Constructor.
*
* @param profile hub discovery object
*/
public HubTester( ClientProfile profile ) throws IOException {
profile_ = profile;
selfIds_ = new HashSet();
privateKeys_ = new HashSet();
// Set up basic information about the hub for use by other methods.
// Perform some checks at the same time.
// First register a probe client to make some basic queries about the
// current hub state.
HubConnection conn = profile_.register();
if ( conn == null ) {
throw new IOException( "No hub is running" );
}
conn.ping();
// Set up monitor to receive hub event messages.
clientWatcher_ = new ClientWatcher( conn );
conn.setCallable( clientWatcher_ );
conn.declareSubscriptions( clientWatcher_.getSubscriptions() );
conn.declareMetadata( clientWatcher_.getMetadata() );
// Acquire, check and store information about the hub.
RegInfo regInfo = conn.getRegInfo();
regInfo.check();
hubId_ = regInfo.getHubId();
// Keep a record of all clients which have registered on behalf of
// this class.
selfIds_.add( regInfo.getSelfId() );
privateKeys_.add( regInfo.getPrivateKey() );
// Get list of registered clients.
String[] clientIds = conn.getRegisteredClients();
// Check that the hub's ID does appear in the list.
assertTrue( Arrays.asList( clientIds ).contains( regInfo.getHubId() ) );
// Check that a client's own ID does not appear in the list.
assertTrue( ! Arrays.asList( clientIds )
.contains( regInfo.getSelfId() ) );
// But prepare a list which contains the client's ID as well.
String[] clientIds1 = new String[ clientIds.length + 1 ];
System.arraycopy( clientIds, 0, clientIds1, 0, clientIds.length );
clientIds1[ clientIds.length ] = regInfo.getSelfId();
clientIds = clientIds1;
// Check that the metadata and subscriptions of all the existing
// clients is legal.
int nc = clientIds.length;
Client[] clients = new Client[ nc ];
for ( int ic = 0; ic < nc; ic++ ) {
final String id = clientIds[ ic ];
final Metadata meta = conn.getMetadata( id );
meta.check();
final Subscriptions subs = conn.getSubscriptions( id );
subs.check();
clients[ ic ] = new Client() {
public String getId() {
return id;
}
public Metadata getMetadata() {
return meta;
}
public Subscriptions getSubscriptions() {
return subs;
}
};
}
ignoreClients_ = clients;
}
/**
* Registers with the hub, performing various checks.
*
* @return new hub connection representing a newly-registered client
*/
private HubConnection register() throws SampException {
HubConnection conn = profile_.register();
RegInfo regInfo = conn.getRegInfo();
regInfo.check();
String selfId = regInfo.getSelfId();
String privateKey = regInfo.getPrivateKey();
// Check that the hub ID is the same for all clients.
assertEquals( hubId_, regInfo.getHubId() );
// Check that client IDs are not being reused.
assertTrue( ! selfIds_.contains( selfId ) );
selfIds_.add( selfId );
// Check that private keys are not being reused.
assertTrue( ! privateKeys_.contains( privateKey ) );
privateKeys_.add( privateKey );
// Check that getRegisteredClients() excludes the caller's ID.
assertTrue( ! Arrays.asList( conn.getRegisteredClients() )
.contains( selfId ) );
// Check that metadata and subscriptions for this application are
// empty maps (since we have not yet declared their values).
assertEquals( new HashMap(), conn.getMetadata( selfId ) );
assertEquals( new HashMap(), conn.getSubscriptions( selfId ) );
return conn;
}
/**
* Perform a wide variety of tests on a running hub.
*/
public void run() throws IOException {
// Profile-specific tests.
if ( profile_ == StandardClientProfile.getInstance() ) {
testStandardLockfile();
}
if ( profile_ instanceof StandardClientProfile ) {
testLockInfo( ((StandardClientProfile) profile_).getLockInfo() );
}
// General tests.
testClients();
testStress();
}
/**
* Tests the content of the SAMP Standard Profile lockfile.
* Does not currently test the permissions on it - that would be nice
* but is hard to do from java since it's rather platform-specific.
*/
private void testStandardLockfile() throws IOException {
LockInfo lockInfo = StandardClientProfile.getInstance().getLockInfo();
if ( lockInfo == null ) {
throw new TestException( "No lockfile (no hub)" );
}
}
/**
* Does tests on a LockInfo object used by the profile.
* This is specific to a Standard-like (though not necessarily Standard)
* profile, and will simply be skipped for non-standard profiles.
*
* @param lockInfo lock info object describing a running hub
*/
private void testLockInfo( LockInfo lockInfo ) throws IOException {
if ( lockInfo == null ) {
throw new TestException( "No LockInfo (no hub)" );
}
lockInfo.check();
String secret = lockInfo.getSecret();
URL hubUrl = lockInfo.getXmlrpcUrl();
TestXmlrpcClient xclient = new TestXmlrpcClient( hubUrl );
xclient.checkSuccessCall( "samp.hub.ping", new ArrayList() );
xclient.checkFailureCall( "samp.hub.register",
Collections.singletonList( secret
+ "-NOT!" ) );
xclient.checkFailureCall( "samp.hub.not-a-method",
Collections.singletonList( secret ) );
}
/**
* Performs a wide variety of tests on a running hub from a limited
* number of clients.
*/
private void testClients() throws IOException {
// Register client0, set metadata and subscriptions, and unregister.
HubConnection c0 = register();
String id0 = c0.getRegInfo().getSelfId();
Metadata meta0 = new Metadata();
meta0.setName( "Shorty" );
meta0.setDescriptionText( "Short-lived test client" );
c0.declareMetadata( meta0 );
TestCallableClient callable0 = new TestCallableClient( c0 );
c0.setCallable( callable0 );
Subscriptions subs0 = new Subscriptions();
subs0.put( ECHO_MTYPE, new HashMap() );
subs0.check();
c0.declareSubscriptions( subs0 );
c0.unregister();
// Register client 1 with the hub and declare some metadata.
HubConnection c1 = register();
String id1 = c1.getRegInfo().getSelfId();
Metadata meta1 = new Metadata();
meta1.setName( "Test1" );
meta1.setDescriptionText( "HubTester client application" );
meta1.put( "test.drink", "cider" );
c1.declareMetadata( meta1 );
// Check the list of clients known to the hub.
assertTestClients( c1, new String[ 0 ] );
// Register client 2 with the hub and declare some metadata.
HubConnection c2 = register();
String id2 = c2.getRegInfo().getSelfId();
Metadata meta2 = new Metadata( meta1 );
meta2.put( "test.drink", "ribena" );
c2.declareMetadata( meta2 );
// Check the list of clients known to the hub.
assertTestClients( c2, new String[] { id1 } );
assertTestClients( c1, new String[] { id2 } );
// Check retrieved metadata matches declared metadata.
assertEquals( meta1, c1.getMetadata( id1 ) );
assertEquals( meta1, c2.getMetadata( id1 ) );
assertEquals( meta2, c1.getMetadata( id2 ) );
assertEquals( meta2, c2.getMetadata( id2 ) );
assertEquals( "cider", c2.getMetadata( id1 ).get( "test.drink" ) );
// Redeclare metadata and check that the update has been noted.
meta1.put( "test.drink", "scrumpy" );
c1.declareMetadata( meta1 );
assertEquals( meta1, c1.getMetadata( id1 ) );
assertEquals( meta1, c2.getMetadata( id1 ) );
assertEquals( "scrumpy", c2.getMetadata( id1 ).get( "test.drink" ) );
// Declare subscriptions and check that retrieved subscriptions match
// declared ones.
TestCallableClient callable1 = new TestCallableClient( c1 );
c1.setCallable( callable1 );
Subscriptions subs1 = new Subscriptions();
subs1.put( "test.dummy.1", new HashMap() );
subs1.put( "test.dummy.2", new HashMap() );
c1.declareSubscriptions( subs1 );
assertEquals( subs1, c1.getSubscriptions( id1 ) );
assertEquals( subs1, c2.getSubscriptions( id1 ) );
Map d3atts = new HashMap();
d3atts.put( "size", "big" );
d3atts.put( "colour", "blue" );
subs1.put( "test.dummy.3", d3atts );
c1.declareSubscriptions( subs1 );
assertEquals( subs1, c2.getSubscriptions( id1 ) );
assertEquals( new HashMap(),
((Map) c2.getSubscriptions( id1 ).get( "test.dummy.1")) );
assertEquals( "big",
((Map) c2.getSubscriptions( id1 ).get( "test.dummy.3" ))
.get( "size" ) );
c1.declareSubscriptions( TestCallableClient.SUBS );
TestCallableClient callable2 = new TestCallableClient( c2 );
c2.setCallable( callable2 );
c2.declareSubscriptions( TestCallableClient.SUBS );
// Try to acquire information about non-existent clients.
try {
c1.getMetadata( "Sir Not-Appearing-in-this-Hub" );
fail();
}
catch ( SampException e ) {
}
try {
c1.getSubscriptions( "Sir Not-Appearing-in-this-Hub" );
fail();
}
catch ( SampException e ) {
}
// New client which can re-use the same tag (not advisable, but legal).
HubConnection c4 = register();
TestCallableClient callable4 = new TestCallableClient( c4 );
callable4.setAllowTagReuse( true );
c4.setCallable( callable4 );
// Send some concurrent ECHO messages via both notify and call.
int necho = 5;
Map[] echoParams = new Map[ necho ];
String[] msgIds2 = new String[ necho ];
String[] msgIds4 = new String[ necho ];
for ( int i = 0; i < necho; i++ ) {
Message msg = new Message( ECHO_MTYPE );
Object val1 = createRandomObject( 2, false );
Object val2 = createRandomObject( 4, false );
Object val3 = new String( GENERAL_CHARS );
msg.put( WAITMILLIS_KEY, SampUtils.encodeInt( 200 + 100 * i ) );
msg.put( MSGIDQUERY_KEY, SampUtils.encodeBoolean( true ) );
msg.addParam( "val1", val1 );
msg.addParam( "val2", val2 );
msg.addParam( "val3", val3 );
echoParams[ i ] = msg.getParams();
c2.notify( id1, msg );
msgIds2[ i ] = callable2.call( id1, "tag" + i, msg );
msgIds4[ i ] = callable4.call( id1, "sametag", msg );
}
// The call messages should complete quickly, so all the sends
// are expected to complete before any of the replies are received
// (there is a deliberate delay at the receiver end in all cases).
// This isn't required, but hubs SHOULD work this way.
// Warn if it looks like not.
if ( callable2.getReplyCount() > necho / 2 ) {
logger_.warning( "Looks like hub call()/notify() methods "
+ "not completing quickly"
+ " (" + callable2.getReplyCount()
+ "/" + necho + ")" );
}
// Spin-wait until all the replies are in.
while ( callable2.getReplyCount() < necho ||
callable4.getReplyCount() < necho ) delay( 100 );
assertEquals( necho, callable2.getReplyCount() );
assertEquals( necho, callable4.getReplyCount() );
// Check that the replies are as expected (returned samp.result has
// same content as sent samp.params).
for ( int i = 0; i < necho; i++ ) {
assertEquals( necho - i, callable2.getReplyCount() );
Response r2 = callable2.getReply( id1, "tag" + i );
assertEquals( Response.OK_STATUS, r2.getStatus() );
assertEquals( echoParams[ i ], r2.getResult() );
assertEquals( msgIds2[ i ], r2.get( MSGIDQUERY_KEY ) );
assertEquals( necho - i, callable4.getReplyCount() );
Response r4 = callable4.getReply( id1, "sametag" );
assertEquals( Response.OK_STATUS, r4.getStatus() );
}
// Check that no more replies have arrived apart from the ones we
// were expecting.
assertEquals( 0, callable2.getReplyCount() );
assertEquals( 0, callable4.getReplyCount() );
// c4 no longer needed.
c4.unregister();
// Send echo messages synchronously (using callAndWait).
// These have deliberate delays at the receiver end, but there is
// no timeout.
for ( int i = 0; i < necho; i++ ) {
Message msg = new Message( ECHO_MTYPE );
Object val1 = createRandomObject( 2, false );
Object val2 = createRandomObject( 4, false );
Object val3 = new String( GENERAL_CHARS );
msg.put( WAITMILLIS_KEY, SampUtils.encodeInt( 100 * i ) );
msg.addParam( "val1", val1 );
msg.addParam( "val2", val2 );
msg.addParam( "val3", val3 );
echoParams[ i ] = msg.getParams();
Response syncR = c2.callAndWait( id1, msg, 0 );
assertEquals( echoParams[ i ], syncR.getResult() );
}
// Send some longer messages synchronously.
{
for ( int ie = 0; ie < 5; ie++ ) {
int num = (int) Math.pow( 10, ie );
List list = new ArrayList( num );
for ( int in = 0; in < num; in++ ) {
list.add( SampUtils.encodeInt( in + 1 ) );
}
Message msg = new Message( ECHO_MTYPE );
msg.addParam( "list", list );
msg.check();
Response response = c2.callAndWait( id1, msg, 0 );
response.check();
assertEquals( Response.OK_STATUS, response.getStatus() );
assertEquals( list, response.getResult().get( "list" ) );
}
}
// Send an echo message synchronously, with a timeout which is shorter
// than the delay which the receiver will introduce. So the hub
// SHOULD time this attempt out before the response is received.
// However, the standard does not REQUIRE this, so just warn in
// case of no time out.
{
Message msg = new Message( ECHO_MTYPE );
msg.addParam( "text", "copy" );
int delay = 10000;
msg.put( WAITMILLIS_KEY, SampUtils.encodeInt( delay ) );
long start = System.currentTimeMillis();
try {
c2.callAndWait( id1, msg, 1 );
assert System.currentTimeMillis() - start >= delay;
logger_.warning( "callAndWait() did not timeout as requested" );
}
catch ( SampException e ) {
// timeout exception
}
}
// Register a new client.
HubConnection c3 = register();
TestCallableClient callable3 = new TestCallableClient( c3 );
c3.setCallable( callable3 );
// Test callAll and notifyAll.
{
// Check that getSubscribedClients returns the right list.
// Note that it must not include the caller.
Set recipientSet = c3.getSubscribedClients( ECHO_MTYPE ).keySet();
try {
assertEquals(
new HashSet( Arrays.asList( new String[] { id1, id2 } ) ),
recipientSet );
}
catch ( TestException e ) {
throw new TestException( "You may need to shut down other "
+ "SAMP clients first", e );
}
// Send an echo message from client 3 using callAll and notifyAll.
// Should go to clients 1 and 2.
Message msg = new Message( ECHO_MTYPE );
Object val4 = createRandomObject( 4, false );
msg.addParam( "val4", val4 );
msg.put( WAITMILLIS_KEY, SampUtils.encodeInt( 400 ) );
List notifyList = c3.notifyAll( msg );
assertEquals( recipientSet, new HashSet( notifyList ) );
String tag = "tag99";
msg.put( MSGIDQUERY_KEY, "1" );
Map callMap = callable3.callAll( tag, msg );
if ( callable3.getReplyCount() != 0 ) {
logger_.warning( "Looks like hub call()/notify() methods "
+ "not completing quickly" );
}
// Retrieve and check the results from the callAll for each
// recipient client.
for ( Iterator it = recipientSet.iterator(); it.hasNext(); ) {
String rid = (String) it.next();
Response response = callable3.waitForReply( rid, tag );
assertEquals( Response.OK_STATUS, response.getStatus() );
assertEquals( val4, response.getResult().get( "val4" ) );
assertEquals( (String) callMap.get( rid ),
response.get( MSGIDQUERY_KEY ) );
}
// Check there are no replies beyond the ones we expect.
assertEquals( 0, callable3.getReplyCount() );
delay( 500 );
// .. even after a while.
assertEquals( 0, callable3.getReplyCount() );
}
// Test that notify- and call-type messages are being received by
// their intended recipients.
{
Message pingMsg = new Message( PING_MTYPE );
pingMsg.put( WAITMILLIS_KEY, SampUtils.encodeInt( 100 ) );
int pingsCount = 50;
Set recipients = c3.getSubscribedClients( PING_MTYPE ).keySet();
assertTrue( recipients.contains( id1 ) );
assertTrue( recipients.contains( id2 ) );
c3.declareSubscriptions( TestCallableClient.SUBS );
assertEquals( recipients,
c3.getSubscribedClients( PING_MTYPE ).keySet() );
// Send a load of messages concurrently using various
// asynchronous methods.
for ( int i = 0; i < pingsCount; i++ ) {
c3.notify( id1, pingMsg );
callable3.call( id1, "abc1-" + i, pingMsg );
List notifyList = c3.notifyAll( pingMsg );
Map callMap = callable3.callAll( "abc2-" + i, pingMsg );
assertEquals( recipients, new HashSet( notifyList ) );
assertEquals( recipients, callMap.keySet() );
}
// Spin-wait until all the clients have received all the messages
// we have sent.
int np1 = pingsCount * 4;
int np2 = pingsCount * 2;
int np3 = 0;
int nr3 = pingsCount * ( 1 + recipients.size() );
while ( callable1.pingCount_ < np1 ||
callable2.pingCount_ < np2 ||
callable3.pingCount_ < np3 ||
callable3.getReplyCount() < nr3 ) delay( 100 );
// And then wait a bit to see if any more come in (hopefully not).
delay( 400 );
// Check that the number of messages received is exactly as
// expected.
assertEquals( np1, callable1.pingCount_ );
assertEquals( np2, callable2.pingCount_ );
assertEquals( np3, callable3.pingCount_ );
assertEquals( nr3, callable3.getReplyCount() );
// Redeclare client 3's subscriptions to the effect that it
// will not receive any messages.
c3.declareSubscriptions( new Subscriptions() );
}
// Test that error data encoded in responses works as it should.
{
Message failMsg = new Message( FAIL_MTYPE );
Map error = new HashMap();
error.put( "samp.errortxt", "failure" );
error.put( "samp.code", "999" );
error.put( "do.what", "do.that" );
failMsg.addParam( ERROR_KEY, error );
Response reply = c3.callAndWait( id2, failMsg, 0 );
ErrInfo errInfo = reply.getErrInfo();
errInfo.check();
assertEquals( Response.ERROR_STATUS, reply.getStatus() );
assertEquals( "failure", errInfo.getErrortxt() );
assertEquals( "999", errInfo.getCode() );
assertEquals( "do.that", errInfo.get( "do.what" ) );
}
// Run tests on MTypes which have not been subscribed to.
{
String dummyMtype = "not.an.mtype";
Message dummyMsg = new Message( dummyMtype );
// Check the hub does not report clients are subscribed to MTypes
// they are not subscribed to.
Set subscribed = c3.getSubscribedClients( dummyMtype ).keySet();
assertTrue( ! subscribed.contains( id1 ) );
assertTrue( ! subscribed.contains( id2 ) );
// Send a message using notify to an unsubscribed recipient.
// This should result in an error.
try {
c3.notify( id1, dummyMsg );
fail();
}
catch ( SampException e ) {
}
// Send a message using call to an unsubscribed recipient.
// This should result in an error.
try {
c3.call( id1, "xxx", dummyMsg );
fail();
}
catch ( SampException e ) {
}
// Send a message using callAndWait to an unsubscribed recipient.
// This should result in an error.
try {
c3.callAndWait( id1, dummyMsg, 0 );
fail();
}
catch ( SampException e ) {
}
// Send message using notifyAll and callAll to which nobody is
// subscribed. Nobody will receive this, but it is not an error.
List notifyList = c3.notifyAll( dummyMsg );
assertEquals( 0, notifyList.size() );
Map callMap = c3.callAll( "yyy", dummyMsg );
assertEquals( 0, callMap.size() );
}
// Check that hub event messages arrived concerning client 0 which
// we registered and unregistered earlier. Do it here to give
// messages enough time to have arrived; SAMP offers no guarantees
// of delivery sequence, but if they haven't showed up yet it's
// very likely that they never will.
Throwable cwError = clientWatcher_.getError();
if ( cwError != null ) {
throw new TestException( "Error encountered during hub event "
+ "processing", cwError );
}
WatchedClient client0 = clientWatcher_.getClient( id0 );
assertTrue( client0 != null );
assertTrue( client0.reg_ );
assertTrue( client0.unreg_ );
assertEquals( meta0, client0.meta_ );
assertEquals( subs0, client0.subs_ );
// Check that the client watcher has received hub event messages
// concerning itself as well.
String cwId = clientWatcher_.getConnection().getRegInfo().getSelfId();
WatchedClient cwClient = clientWatcher_.getClient( cwId );
assertTrue( cwClient != null );
assertTrue( ! cwClient.unreg_ );
assertEquals( clientWatcher_.getMetadata(), cwClient.meta_ );
assertEquals( clientWatcher_.getSubscriptions(), cwClient.subs_ );
// Tidy up.
c3.unregister();
assertTestClients( c1, new String[] { id2, } );
assertTestClients( c2, new String[] { id1, } );
c1.unregister();
c2.unregister();
}
/**
* Runs a lot of clients throwing a lot of messages at each other
* simultaneously.
*/
private void testStress() throws IOException {
ClientProfile profile = new ClientProfile() {
public boolean isHubRunning() {
return HubTester.this.profile_.isHubRunning();
}
public HubConnection register() throws SampException {
return HubTester.this.register();
}
};
new CalcStorm( profile, random_, 10, 20, Calculator.RANDOM_MODE )
.run();
}
/**
* Assert that the given list of registered clients has a certain content.
*
* @param conn connection from which to call getRegisteredClients
* @param otherIds array of client public IDs that getRegisteredClients
* should return - will not contain ID associated with
* conn itself
*/
private void assertTestClients( HubConnection conn, String[] otherIds )
throws IOException {
// Call getRegisteredClients.
Set knownOtherIds =
new HashSet( Arrays.asList( conn.getRegisteredClients() ) );
// Remove from the list any clients which were already registered
// before this test instance started up.
for ( int ic = 0; ic < ignoreClients_.length; ic++ ) {
String id = ignoreClients_[ ic ].getId();
knownOtherIds.remove( ignoreClients_[ ic ].getId() );
}
// Assert that the (unordered) set retrieved is the same as that
// asked about.
assertEquals( knownOtherIds,
new HashSet( Arrays.asList( otherIds ) ) );
}
/**
* Generates an object with random content for transmission using SAMP.
* This may be a structure containing strings, lists and maps with
* any legal values as defined by the SAMP data encoding rules.
*
* @param level maximum level of nesting (how deeply lists/maps
* may appear within other lists/maps)
* @param ugly if true, any legal SAMP content will be used;
* if false, the returned object should be reasonably
* human-readable if printed (toString)
* @return random SAMP object
*/
public Object createRandomObject( int level, boolean ugly ) {
if ( level == 0 ) {
return createRandomString( ugly );
}
int type = random_.nextInt( 2 );
if ( type == 0 ) {
int nel = random_.nextInt( ugly ? 23 : 3 );
List list = new ArrayList( nel );
for ( int i = 0; i < nel; i++ ) {
list.add( createRandomObject( level - 1, ugly ) );
}
SampUtils.checkList( list );
return list;
}
else if ( type == 1 ) {
int nent = random_.nextInt( ugly ? 23 : 3 );
Map map = new HashMap( nent );
for ( int i = 0; i < nent; i++ ) {
map.put( createRandomString( ugly ),
createRandomObject( level - 1, ugly ) );
}
SampUtils.checkMap( map );
return map;
}
else {
throw new AssertionError();
}
}
/**
* Creates a new random string for transmission using SAMP.
* This may have any legal content according to the SAMP data encoding
* rules.
*
* @param ugly if true, any legal SAMP content will be used;
* if false, the returned object should be reasonably
* human-readable if printed (toString)
*/
public String createRandomString( boolean ugly ) {
int nchar = random_.nextInt( ugly ? 99 : 4 );
StringBuffer sbuf = new StringBuffer( nchar );
char[] chrs = ugly ? GENERAL_CHARS : ALPHA_CHARS;
for ( int i = 0; i < nchar; i++ ) {
sbuf.append( chrs[ random_.nextInt( chrs.length ) ] );
}
String str = sbuf.toString();
SampUtils.checkString( str );
return str;
}
/**
* Waits for a given number of milliseconds.
*
* @param millis number of milliseconds
*/
private static void delay( int millis ) {
Object lock = new Object();
try {
synchronized ( lock ) {
lock.wait( millis );
}
}
catch ( InterruptedException e ) {
throw new RuntimeException( "Interrupted", e );
}
}
/**
* Returns a character array containing each distinct alphanumeric
* character.
*
* @return array of alphanumeric characters
*/
private static char[] createAlphaCharacters() {
StringBuffer sbuf = new StringBuffer();
for ( char c = 'A'; c <= 'Z'; c++ ) {
sbuf.append( c );
}
for ( char c = '0'; c <= '9'; c++ ) {
sbuf.append( c );
}
return sbuf.toString().toCharArray();
}
/**
* Returns a character array containing every character which is legal
* for inclusion in a SAMP string.
*
* @return array of string characters
*/
private static char[] createGeneralCharacters() {
StringBuffer sbuf = new StringBuffer();
sbuf.append( (char) 0x09 );
sbuf.append( (char) 0x0a );
// Character 0x0d is problematic. Although it is permissible to
// transmit this in an XML document, it can get transformed to
// 0x0a or (if adjacent to an existing 0x0a) elided.
// The correct thing to do probably would be to note in the standard
// that all bets are off when transmitting line end characters -
// but sending a line-end will probably end up as a line-end.
// However I can't be bothered to start up a new thread about this
// on the apps-samp list, so for the purposes of this test just
// avoid sending it.
// sbuf.append( (char) 0x0d );
for ( char c = 0x20; c <= 0x7f; c++ ) {
sbuf.append( c );
}
return sbuf.toString().toCharArray();
}
/**
* Main method. Tests a hub which is currently running.
*/
public static void main( String[] args ) throws IOException {
int status = runMain( args );
if ( status != 0 ) {
System.exit( status );
}
}
/**
* Does the work for the main method.
* Use -help flag.
*/
public static int runMain( String[] args ) throws IOException {
String usage = new StringBuffer()
.append( "\n Usage:" )
.append( "\n " )
.append( HubTester.class.getName() )
.append( "\n " )
.append( " [-help]" )
.append( " [-/+verbose]" )
.append( "\n " )
.append( " [-gui]" )
.append( "\n" )
.toString();
List argList = new ArrayList( Arrays.asList( args ) );
boolean gui = false;
int verbAdjust = 0;
for ( Iterator it = argList.iterator(); it.hasNext(); ) {
String arg = (String) it.next();
if ( arg.equals( "-gui" ) ) {
it.remove();
gui = true;
}
else if ( arg.equals( "-nogui" ) ) {
it.remove();
gui = false;
}
else if ( arg.startsWith( "-v" ) ) {
it.remove();
verbAdjust--;
}
else if ( arg.startsWith( "+v" ) ) {
it.remove();
verbAdjust++;
}
else if ( arg.startsWith( "-h" ) ) {
it.remove();
System.out.println( usage );
return 0;
}
else {
it.remove();
System.err.println( usage );
return 1;
}
}
assert argList.isEmpty();
// Adjust logging in accordance with verboseness flags.
int logLevel = Level.WARNING.intValue() + 100 * verbAdjust;
Logger.getLogger( "org.astrogrid.samp" )
.setLevel( Level.parse( Integer.toString( logLevel ) ) );
// Get profile.
ClientProfile profile = DefaultClientProfile.getProfile();
// Set up GUI monitor if required.
JFrame frame;
if ( gui ) {
frame = new JFrame( "HubTester Monitor" );
frame.getContentPane().add( new HubMonitor( profile, true, 1 ) );
frame.pack();
frame.setVisible( true );
}
else {
frame = null;
}
new HubTester( profile ).run();
if ( frame != null ) {
frame.dispose();
}
return 0;
}
/**
* CallableClient implementation for testing.
*/
private static class TestCallableClient extends ReplyCollector
implements CallableClient {
private final HubConnection connection_;
private int pingCount_;
public static final Subscriptions SUBS = getSubscriptions();
/**
* Constructor.
*
* @param connection hub connection
*/
TestCallableClient( HubConnection connection ) {
super( connection );
connection_ = connection;
}
public void receiveNotification( String senderId, Message msg ) {
processCall( senderId, msg );
}
public void receiveCall( String senderId, String msgId, Message msg )
throws SampException {
// If the message contains a WAITMILLIS_KEY entry, interpret this
// as a number of milliseconds to wait before the response is
// sent back to the hub.
String swaitMillis = (String) msg.get( WAITMILLIS_KEY );
if ( swaitMillis != null ) {
int waitMillis = SampUtils.decodeInt( swaitMillis );
if ( waitMillis > 0 ) {
delay( waitMillis );
}
}
Response response;
// Process a FAIL_MTYPE message specially.
if ( msg.getMType().equals( FAIL_MTYPE ) ) {
Map errs = (Map) msg.getParam( ERROR_KEY );
if ( errs == null ) {
throw new IllegalArgumentException();
}
response = Response.createErrorResponse( new ErrInfo( errs ) );
}
// For other MTypes, pass them to the processCall method.
else {
try {
response =
Response
.createSuccessResponse( processCall( senderId, msg ) );
}
catch ( Throwable e ) {
response = Response.createErrorResponse( new ErrInfo( e ) );
}
}
// Insert the message ID into the response if requested to do so.
String msgIdQuery = (String) msg.get( MSGIDQUERY_KEY );
if ( msgIdQuery != null && SampUtils.decodeBoolean( msgIdQuery ) ) {
response.put( MSGIDQUERY_KEY, msgId );
}
response.check();
// Return the reply, whatever it is, to the hub.
connection_.reply( msgId, response );
}
/**
* Do the work of responding to a given SAMP message.
*
* @param senderId sender public ID
* @param msg message object
* @return content of the successful reply's samp.result entry
*/
private Map processCall( String senderId, Message msg ) {
String mtype = msg.getMType();
// Returns the samp.params entry as the samp.result entry.
if ( ECHO_MTYPE.equals( mtype ) ) {
return msg.getParams();
}
// Just bumps a counter and returns an empty samp.result
else if ( PING_MTYPE.equals( mtype ) ) {
synchronized ( this ) {
pingCount_++;
}
return new HashMap();
}
// Shouldn't happen.
else {
throw new TestException( "Unsubscribed MType? " + mtype );
}
}
/**
* Returns the subscriptions object for this client.
*
* @return subscriptions
*/
private static Subscriptions getSubscriptions() {
Subscriptions subs = new Subscriptions();
subs.addMType( ECHO_MTYPE );
subs.addMType( PING_MTYPE );
subs.addMType( FAIL_MTYPE );
subs.check();
return subs;
}
}
/**
* CallableClient implementation which watches hub.event messages
* concerning the registration and attributes of other clients.
*/
private static class ClientWatcher implements CallableClient {
private final HubConnection connection_;
private final Map clientMap_;
private Throwable error_;
/**
* Constructor.
*
* @param connection hub connection
*/
ClientWatcher( HubConnection connection ) {
connection_ = connection;
clientMap_ = Collections.synchronizedMap( new HashMap() );
}
/**
* Returns a WatchedClient object corresponding to a given client
* public ID. This will contain information about the hub event
* messages this watcher has received concerning that client up till
* now.
*
* @param id public id of a client which has been registered
* @return watchedClient object if any messages have been received
* about id, otherwise null
*/
public WatchedClient getClient( String id ) {
return (WatchedClient) clientMap_.get( id );
}
/**
* Returns an error if any error has been thrown during processing
* of hub event messages.
*
* @return deferred throwable, or null in case of no problems
*/
public Throwable getError() {
return error_;
}
/**
* Returns the hub connection used by this client.
*
* @return hub connection
*/
public HubConnection getConnection() {
return connection_;
}
public void receiveCall( String senderId, String msgId, Message msg ) {
receiveNotification( senderId, msg );
Response response =
error_ == null
? Response.createSuccessResponse( new HashMap() )
: Response.createErrorResponse( new ErrInfo( "broken" ) );
try {
connection_.reply( msgId, response );
}
catch ( SampException e ) {
error_ = e;
}
}
public void receiveNotification( String senderId, Message msg ) {
if ( error_ == null ) {
try {
processMessage( senderId, msg );
}
catch ( Throwable e ) {
error_ = e;
}
}
}
private void processMessage( String senderId, Message msg )
throws IOException {
// Check the message actually comes from the hub.
assertEquals( senderId, connection_.getRegInfo().getHubId() );
String mtype = msg.getMType();
Map params = msg.getParams();
// Get (if necessary lazily creating) a WatchedClient object
// which this message concerns.
String id = (String) msg.getParam( "id" );
assertTrue( id != null );
synchronized ( clientMap_ ) {
if ( ! clientMap_.containsKey( id ) ) {
clientMap_.put( id, new WatchedClient() );
}
WatchedClient client = (WatchedClient) clientMap_.get( id );
// Handle the various hub event messages by updating fields of
// the right WatchedClient object.
if ( REGISTER_MTYPE.equals( mtype ) ) {
assertTrue( ! client.reg_ );
client.reg_ = true;
}
else if ( UNREGISTER_MTYPE.equals( mtype ) ) {
assertTrue( ! client.unreg_ );
client.unreg_ = true;
}
else if ( METADATA_MTYPE.equals( mtype ) ) {
assertTrue( params.containsKey( "metadata" ) );
Metadata meta =
Metadata
.asMetadata( (Map) params.get( "metadata" ) );
meta.check();
client.meta_ = meta;
}
else if ( SUBSCRIPTIONS_MTYPE.equals( mtype ) ) {
assertTrue( params.containsKey( "subscriptions" ) );
Subscriptions subs =
Subscriptions
.asSubscriptions( (Map) params.get( "subscriptions" ) );
subs.check();
client.subs_ = subs;
}
else {
fail();
}
clientMap_.notifyAll();
}
}
public void receiveResponse( String responderId, String msgTag,
Response response ) {
throw new UnsupportedOperationException();
}
/**
* Returns a suitable subscriptions object for this client.
*
* @return subscriptions
*/
public static Subscriptions getSubscriptions() {
Subscriptions subs = new Subscriptions();
subs.addMType( REGISTER_MTYPE );
subs.addMType( UNREGISTER_MTYPE );
subs.addMType( METADATA_MTYPE );
subs.addMType( SUBSCRIPTIONS_MTYPE );
subs.check();
return subs;
}
/**
* Returns a suitable metadata object for this client.
*/
public static Metadata getMetadata() {
Metadata meta = new Metadata();
meta.setName( "ClientWatcher" );
meta.setDescriptionText( "Tracks other clients for HubTester" );
meta.check();
return meta;
}
}
/**
* Struct-type utility class which aggregates mutable information about
* a client, to be updated in response to hub event messages.
*/
private static class WatchedClient {
/** Whether this client has ever been registered. */
boolean reg_;
/** Whether this clent has ever been unregistered. */
boolean unreg_;
/** Current metadata object for this client. */
Metadata meta_;
/** Current subscriptions object for this client. */
Subscriptions subs_;
}
}