aboutsummaryrefslogtreecommitdiff
path: root/tests/AsyncAPI.java
diff options
context:
space:
mode:
Diffstat (limited to 'tests/AsyncAPI.java')
-rw-r--r--tests/AsyncAPI.java150
1 files changed, 150 insertions, 0 deletions
diff --git a/tests/AsyncAPI.java b/tests/AsyncAPI.java
new file mode 100644
index 0000000..eca9ddc
--- /dev/null
+++ b/tests/AsyncAPI.java
@@ -0,0 +1,150 @@
+/**
+ * Ivy java Async API tester: bindAsyncMsg, sendAsyncMsg.
+ *
+ * @author Yannick Jestin <mailto:jestin@cena.fr>
+ *
+ * (c) CENA
+ *
+ * usage: java AsyncAPI -h
+ *
+ * this program tests the Asynchronous reception of messages ( each callback
+ * is performed in a separate threads ). It also exhibits the behaviour of the
+ * library with regards to concurrent connections ! To stress the test, try it
+ * with different JVM ( kaffe is especially hard to pass ), and on SMP
+ * machines ...
+ *
+ * changelog
+ *
+ * 1.2.6 : async sending seems utterly buggy ...
+ *
+ */
+import fr.dgac.ivy.*;
+import gnu.getopt.*;
+
+class AsyncAPI {
+
+ public static final int MSGSIZE = 10;
+ public static final int NBITER = 100;
+ public static final int DELAYMS = 1000;
+ public static final String HEADER = "ASYNCPACKET";
+ public static final String TOSUBSCRIBE = "^"+HEADER+"([0-9]*) (.*)";
+ public static final String RECEIVENAME = "MSreceive";
+ public static final String SENDNAME = "MSsend";
+ private static long epoch = System.currentTimeMillis();
+
+ private Ivy bus;
+ DelayAnswer delay;
+ int re;
+ private String name;
+ boolean verbose;
+ private int nbpacket;
+ private int count=0,total=0;
+ protected Integer truc = new Integer(0);
+
+ public AsyncAPI(int nb,String domain,int d, boolean v,boolean async) throws IvyException {
+ verbose=v;
+ nbpacket=nb;
+ name = "MSreceive";
+ bus = new Ivy(name,name+" Ready", null);
+ delay=new DelayAnswer(d);
+ if (async)
+ re = bus.bindAsyncMsg(TOSUBSCRIBE,delay);
+ else
+ re = bus.bindMsg(TOSUBSCRIBE,delay);
+ bus.start(domain);
+ }
+
+ private static java.text.DateFormat df = java.text.DateFormat.getTimeInstance();
+ private static String date() {
+ return "["+df.format(new java.util.Date())+"] ";
+ }
+
+ class DelayAnswer implements IvyMessageListener {
+ int delay;
+ public DelayAnswer(int delay) {
+ this.delay=delay;
+ }
+ public void receive(IvyClient ic, String[] args) {
+ synchronized(truc) {
+ count++;
+ if (verbose) {
+ System.out.println(date()+count+"/"+nbpacket+" packets received ("+args[0]+")");
+ total+=Integer.parseInt(args[0]);
+ }
+ if (count<nbpacket) return;
+ if (total==(((nbpacket+1)*nbpacket)/2)) {
+ System.out.println("receiver quitting the bus normally");
+ ic.sendDie("ok, bye");
+ bus.stop();
+ } else {
+ System.out.println("wrong count and total, hit ^C to exit");
+ //System.exit(-1);
+ }
+ }
+ try { Thread.sleep(delay); } catch (InterruptedException ie) { }
+ }
+ }
+
+ public static final String helpmsg = "usage: java "+SENDNAME+" [options]\n\t-b domain\n\t-r\t to enable async reception\n\t-x to enable async sending\n\t-l loop count (default "+NBITER+")\n\t-s msgsize\t int value (default "+MSGSIZE+")\n\t-d delay in milliseconds (default "+DELAYMS+")\n\t-q \tquiet\n\t-e\tsend bus stop at the end\n\t-h\thelp\n\n";
+ public static void main(String[] args) throws IvyException {
+ Getopt opt = new Getopt(SENDNAME,args,"b:l:d:s:xrqeh");
+ String domain=Ivy.getDomain(null); // default bus
+ int nb = NBITER, delay = DELAYMS, c, size = MSGSIZE;
+ boolean doasyncSend=false, doasyncBind=false, verbose=true, exit=false;
+ while ((c = opt.getopt()) != -1) switch (c) {
+ case 'b':
+ domain=opt.getOptarg();
+ break;
+ case 's':
+ size=Integer.parseInt(opt.getOptarg());
+ break;
+ case 'l':
+ nb=Integer.parseInt(opt.getOptarg());
+ break;
+ case 'd':
+ delay=Integer.parseInt(opt.getOptarg());
+ break;
+ case 'e':
+ exit=true;
+ break;
+ case 'q':
+ verbose=false;
+ break;
+ case 'x':
+ System.out.println("async sending is not robust enough. end of test.");
+ System.exit(-1);
+ doasyncSend=true;
+ break;
+ case 'r':
+ doasyncBind=true;
+ break;
+ case 'h':
+ default:
+ System.out.println(helpmsg);
+ System.exit(0);
+ }
+ System.out.println("bus:"+domain+" loop:"+nb+" delay:"+delay+" verbose:"+verbose+" asyncBind:"+
+ doasyncBind+" asyncSend:"+doasyncSend+" msgsize:"+size);
+
+ AsyncAPI receiver = new AsyncAPI(nb,domain,delay,verbose,doasyncBind);
+ Ivy mainbus = new Ivy(SENDNAME,SENDNAME+" Ready", null);
+ mainbus.start(domain);
+ if ((mainbus.waitForClient(RECEIVENAME,5000))==null) {
+ System.out.println(RECEIVENAME+" did not join the bus. Quitting");
+ System.exit(0);
+ }
+ System.out.println(RECEIVENAME+" is here, sending packets");
+ StringBuffer tosend = new StringBuffer(size);
+ for (int i=0;i<size;i++) tosend.append("a");
+ for (int i=1;i<=nb;i++) {
+ if (verbose) System.out.println(date()+"sending packet "+i);
+ mainbus.sendMsg(HEADER+i+" "+tosend.toString());
+ // mainbus.sendMsg(HEADER+i+" "+tosend.toString(),doasyncSend);
+ }
+ System.out.println(date()+"sender has sent all its packets, waiting for a die message");
+ // i won't stop the sender's bus here, otherwise the all the packet
+ // can still be unprocessed
+ // TODO regession test for Ivy.stop()
+ }
+
+}