package org.astrogrid.samp.test; import java.io.IOException; import java.io.PrintStream; import java.util.AbstractMap; import java.util.AbstractSet; import java.util.ArrayList; import java.util.Arrays; import java.util.BitSet; import java.util.Collection; 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 java.util.logging.Level; import java.util.logging.Logger; import org.astrogrid.samp.Client; import org.astrogrid.samp.Message; import org.astrogrid.samp.Metadata; 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; /** * Sends a message to one or more other SAMP clients. * Intended for use from the command line. * * @author Mark Taylor * @since 23 Jul 2008 */ public abstract class MessageSender { private static Logger logger_ = Logger.getLogger( MessageSender.class.getName() ); /** * Sends a message to a given list of recipients. * If recipientIds is null, then will be sent to all * subscribed clients. * * @param connection hub connection * @param msg message to send * @param recipientIds array of recipients to target, or null * @return responder Client -> Response map */ abstract Map getResponses( HubConnection connection, Message msg, String[] recipientIds ) throws IOException; /** * Sends a message to a list of recipients and displays the results * on an output stream. * * @param connection hub connection * @param msg message to send * @param recipientIds array of recipients to target, or null * @param destination print stream */ void showResults( HubConnection connection, Message msg, String[] recipientIds, PrintStream out ) throws IOException { Map responses = getResponses( connection, msg, recipientIds ); for ( Iterator it = responses.entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = (Map.Entry) it.next(); String responderId = (String) entry.getKey(); Client responder = new MetaClient( responderId, connection ); Object response = entry.getValue(); out.println(); out.println( responder ); if ( response instanceof Throwable ) { ((Throwable) response).printStackTrace( out ); } else { out.println( SampUtils.formatObject( response, 3 ) ); } } } /** * Translates an array of client names to client IDs. * If some or all cannot be identified, an exception is thrown. * * @param conn hub connection * @param names array of client names, interpreted case-insensitively * @return array of client ids corresponding to names */ private static String[] namesToIds( HubConnection conn, String[] names ) throws SampException { int count = names.length; if ( count == 0 ) { return new String[ 0 ]; } String[] ids = new String[ count ]; BitSet flags = new BitSet( count ); String[] allIds = conn.getRegisteredClients(); for ( int ic = 0; ic < allIds.length; ic++ ) { String id = allIds[ ic ]; Metadata meta = conn.getMetadata( id ); String name = meta.getName(); for ( int in = 0; in < count; in++ ) { if ( names[ in ].equalsIgnoreCase( name ) ) { ids[ in ] = id; flags.set( in ); } } if ( flags.cardinality() == count ) { return ids; } } assert flags.cardinality() < count; List unknownList = new ArrayList(); for ( int in = 0; in < count; in++ ) { if ( ids[ in ] == null ) { unknownList.add( names[ in ] ); } } throw new SampException( "Unknown client " + ( unknownList.size() == 1 ? ( "name " + unknownList.get( 0 ) ) : ( "names " + unknownList ) ) ); } /** * Main method. * Use -help flag for documentation. */ 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. */ public static int runMain( String[] args ) throws IOException { // Assemble usage string. String usage = new StringBuffer() .append( "\n Usage:" ) .append( "\n " + MessageSender.class.getName() ) .append( "\n " ) .append( " [-help]" ) .append( " [-/+verbose]" ) .append( "\n " ) .append( " -mtype " ) .append( " [-param ...]" ) .append( " [-mode sync|async|notify]" ) .append( "\n " ) .append( " [-targetid ...]" ) .append( " [-targetname ...]" ) .append( "\n " ) .append( " [-sendername ]" ) .append( " [-sendermeta ]" ) .append( "\n" ) .toString(); // Set up variables which can be set or changed by the argument list. String mtype = null; List targetIdList = new ArrayList(); List targetNameList = new ArrayList(); Map paramMap = new HashMap(); String mode = "sync"; Metadata meta = new Metadata(); int timeout = 0; int verbAdjust = 0; // Parse the argument list. List argList = new ArrayList( Arrays.asList( args ) ); for ( Iterator it = argList.iterator(); it.hasNext(); ) { String arg = (String) it.next(); if ( arg.equals( "-mtype" ) && it.hasNext() ) { it.remove(); if ( mtype != null ) { System.err.println( usage ); return 1; } mtype = (String) it.next(); it.remove(); } else if ( arg.equals( "-targetid" ) && it.hasNext() ) { it.remove(); targetIdList.add( (String) it.next() ); it.remove(); } else if ( arg.equals( "-targetname" ) && it.hasNext() ) { it.remove(); targetNameList.add( (String) it.next() ); it.remove(); } else if ( arg.equals( "-param" ) && it.hasNext() ) { it.remove(); String pName = (String) it.next(); it.remove(); String pValue; if ( it.hasNext() ) { pValue = (String) it.next(); it.remove(); } else { System.err.println( usage ); return 1; } paramMap.put( pName, SampUtils.parseValue( pValue ) ); } else if ( arg.equals( "-mode" ) && it.hasNext() ) { it.remove(); mode = (String) it.next(); it.remove(); } else if ( arg.equals( "-sendername" ) && it.hasNext() ) { it.remove(); meta.setName( (String) it.next() ); it.remove(); } else if ( arg.equals( "-sendermeta" ) && it.hasNext() ) { it.remove(); String mName = (String) it.next(); it.remove(); String mValue; if ( it.hasNext() ) { mValue = (String) it.next(); it.remove(); } else { System.err.println( usage ); return 1; } meta.put( mName, SampUtils.parseValue( mValue ) ); } else if ( arg.equals( "-timeout" ) && it.hasNext() ) { it.remove(); String stimeout = (String) it.next(); it.remove(); try { timeout = Integer.parseInt( stimeout ); } catch ( NumberFormatException e ) { System.err.println( "Not numeric: " + stimeout ); System.err.println( usage ); return 1; } } 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; } } if ( ! argList.isEmpty() ) { System.err.println( usage ); return 1; } if ( mtype == null ) { System.err.println( usage ); return 1; } // Set logging levels in accordance with 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(); // Create a message sender object. final MessageSender sender; if ( mode.toLowerCase().startsWith( "async" ) ) { sender = new AsynchSender(); } else if ( mode.toLowerCase().startsWith( "sync" ) ) { sender = new SynchSender( timeout ); } else if ( mode.toLowerCase().startsWith( "notif" ) ) { sender = new NotifySender(); } else { System.err.println( usage ); return 1; } // Prepare to send the message. Message msg = new Message( mtype, paramMap ); // Register. HubConnection connection = profile.register(); if ( connection == null ) { System.err.println( "No hub is running" ); return 1; } connection.declareMetadata( meta ); // Assemble target list. String[] targetNames = (String[]) targetNameList.toArray( new String[ 0 ] ); targetIdList.addAll( Arrays.asList( namesToIds( connection, targetNames ) ) ); String[] targets = targetIdList.isEmpty() ? null : (String[]) targetIdList.toArray( new String[ 0 ] ); // Send the message, displaying the results on System.out. sender.showResults( connection, msg, targets, System.out ); // Tidy up and exit. connection.unregister(); return 0; } /** * MessageSender implementation which uses the Notify pattern. */ private static class NotifySender extends MessageSender { public Map getResponses( HubConnection connection, Message msg, String[] recipientIds ) throws IOException { final List recipientList; if ( recipientIds == null ) { recipientList = connection.notifyAll( msg ); if ( recipientList.size() == 0 ) { logger_.warning( "No clients subscribed to " + msg.getMType() ); } } else { for ( int ir = 0; ir < recipientIds.length; ir++ ) { connection.notify( recipientIds[ ir ], msg ); } recipientList = Arrays.asList( recipientIds ); } Map responseMap = new HashMap(); for ( Iterator it = recipientList.iterator(); it.hasNext(); ) { responseMap.put( it.next(), "" ); } return responseMap; } } /** * MessageSender implementation which uses the Synchronous Call/Response * pattern. */ private static class SynchSender extends MessageSender { private final int timeout_; /** * Constructor. * * @param timeout in seconds */ SynchSender( int timeout ) { timeout_ = timeout; } public Map getResponses( final HubConnection connection, final Message msg, String[] recIds ) throws IOException { final String[] recipientIds = recIds == null ? (String[]) connection.getSubscribedClients( msg.getMType() ) .keySet().toArray( new String[ 0 ] ) : recIds; if ( recipientIds.length == 0 ) { logger_.warning( "No clients subscribed to " + msg.getMType() ); return new HashMap(); } else { int nsend = recipientIds.length; logger_.log( nsend == 0 ? Level.WARNING : Level.INFO, "Waiting for " + nsend + " responses" ); } final BlockingMap map = new BlockingMap(); for ( int ir = 0; ir < recipientIds.length; ir++ ) { final String id = recipientIds[ ir ]; new Thread() { public void run() { Object result; try { result = connection.callAndWait( id, msg, timeout_ ); } catch ( Throwable e ) { result = e; } map.put( id, result ); if ( map.size() >= recipientIds.length ) { map.done(); } } }.start(); } return map; } } /** * MessageSender implementation which uses the Asynchronous Call/Response * pattern. */ private static class AsynchSender extends MessageSender { private int iseq_; public Map getResponses( HubConnection connection, Message msg, String[] recipientIds ) throws IOException { String msgTag = "tag-" + ++iseq_; Collector collector = new Collector(); // Sets the connection's callable client to a new object. // Since the Standard Profile doesn't say it's OK to do this // more than once, this means that this it is not really safe // to call getResponses more than once for this object. connection.setCallable( collector ); if ( recipientIds == null ) { Set recipientSet = connection.callAll( msgTag, msg ).keySet(); collector.setRecipients( recipientSet ); } else { Set recipientSet = new HashSet( Arrays.asList( recipientIds ) ); for ( Iterator it = recipientSet.iterator(); it.hasNext(); ) { String recipientId = (String) it.next(); connection.call( recipientId, msgTag, msg ); } collector.setRecipients( recipientSet ); } return collector.map_; } /** * CallableClient implementation which collects asynchronous message * responses. */ private static class Collector implements CallableClient { final BlockingMap map_; Collection recipients_; /** * Constructor. * * @param nExpected number of responses expected by this collector */ Collector() { map_ = new BlockingMap(); } /** * Notifies this object which clients it should expect a response * from. Must be called at some point, or the returned map's * iterator will block indefinitely. * * @param recipients set of client ids for expected responders */ public void setRecipients( Collection recipients ) { int nsend = recipients.size(); logger_.log( nsend == 0 ? Level.WARNING : Level.INFO, "Waiting for " + nsend + " responses" ); recipients_ = recipients; if ( map_.keySet().containsAll( recipients_ ) ) { map_.done(); } } public void receiveCall( String senderId, String msgId, Message msg ) { throw new UnsupportedOperationException(); } public void receiveNotification( String senderId, Message msg ) { throw new UnsupportedOperationException(); } public void receiveResponse( String responderId, String msgTag, Response response ) { map_.put( responderId, response ); if ( recipients_ != null && map_.keySet().containsAll( recipients_ ) ) { map_.done(); } } } } /** * Client implementation which may know about metadata. */ private static class MetaClient implements Client { private final String id_; private final Metadata meta_; /** * Constructor which attempts to acquire metadata from a given * hub connection. * * @param client id * @param connection hub connection */ public MetaClient( String id, HubConnection connection ) throws SampException { this( id, connection.getMetadata( id ) ); } /** * Constructor which uses supplied metadata. * * @param id client id * @param meta metadata (may be null) */ public MetaClient( String id, Metadata meta ) { id_ = id; meta_ = meta; } public String getId() { return id_; } public Metadata getMetadata() { return meta_; } public Subscriptions getSubscriptions() { return null; } public String toString() { StringBuffer sbuf = new StringBuffer(); sbuf.append( getId() ); String name = meta_ == null ? null : meta_.getName(); if ( name != null ) { sbuf.append( " (" ) .append( name ) .append( ')' ); } return sbuf.toString(); } } /** * Map implementation which dispenses its contents via an iterator * which will block until all the results are in. This makes it * suitable for use from other threads. */ private static class BlockingMap extends AbstractMap { private final BlockingSet entrySet_; /** * Constructor. */ BlockingMap() { entrySet_ = new BlockingSet(); } public Set entrySet() { return entrySet_; } public synchronized Object put( final Object key, final Object value ) { entrySet_.add( new Map.Entry() { public Object getKey() { return key; } public Object getValue() { return value; } public Object setValue( Object value ) { throw new UnsupportedOperationException(); } } ); return null; } /** * Indicates that no more entries will be added to this map. * Must be called by populator or entry set iterator will block * indefinitely. */ synchronized void done() { entrySet_.done(); } } /** * Set implementation which dispenses its contents via an iterator * which will block until all results are in. */ private static class BlockingSet extends AbstractSet { private final List list_; private boolean done_; /** * Constructor. */ BlockingSet() { list_ = Collections.synchronizedList( new ArrayList() ); } public boolean add( Object o ) { assert ! list_.contains( o ); synchronized ( list_ ) { list_.add( o ); list_.notifyAll(); } return true; } /** * Indicates that no more items will be added to this set. * Must be called by populator or iterator will block * indefinitely. */ public void done() { done_ = true; synchronized ( list_ ) { list_.notifyAll(); } } public int size() { return list_.size(); } public Iterator iterator() { return new Iterator() { int index_; public void remove() { throw new UnsupportedOperationException(); } public Object next() { return list_.get( index_++ ); } public boolean hasNext() { synchronized ( list_ ) { while ( index_ >= list_.size() && ! done_ ) { try { list_.wait(); } catch ( InterruptedException e ) { throw new RuntimeException( "Interrupted", e ); } } return index_ < list_.size(); } } }; } } }