1   /*
2    * $Id: AbstractTransactionQueueManagerTestCase.java 7963 2007-08-21 08:53:15Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.util.queue;
12  
13  import org.mule.tck.AbstractMuleTestCase;
14  import org.mule.util.concurrent.Latch;
15  import org.mule.util.xa.AbstractResourceManager;
16  
17  import java.util.Random;
18  
19  import org.apache.commons.logging.Log;
20  import org.apache.commons.logging.LogFactory;
21  
22  public abstract class AbstractTransactionQueueManagerTestCase extends AbstractMuleTestCase
23  {
24  
25      /**
26       * logger used by this class
27       */
28      protected transient Log logger = LogFactory.getLog(getClass());
29  
30      protected abstract TransactionalQueueManager createQueueManager() throws Exception;
31  
32      protected abstract boolean isPersistent();
33  
34      public void testPutTake() throws Exception
35      {
36          TransactionalQueueManager mgr = createQueueManager();
37          mgr.start();
38  
39          QueueSession s = mgr.getQueueSession();
40          Queue q = s.getQueue("queue1");
41  
42          assertEquals(0, q.size());
43          // Object o = q.take();
44          // assertNull(o);
45          q.put("String1");
46          assertEquals(1, q.size());
47          Object o = q.take();
48          assertNotNull(o);
49          assertEquals("String1", o);
50          assertEquals(0, q.size());
51  
52          mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
53      }
54  
55      public void testTakePut() throws Exception
56      {
57          final TransactionalQueueManager mgr = createQueueManager();
58          mgr.start();
59  
60          final Latch latch = new Latch();
61  
62          Thread t = new Thread()
63          {
64              public void run()
65              {
66                  try
67                  {
68                      latch.countDown();
69                      Thread.sleep(200);
70                      QueueSession s = mgr.getQueueSession();
71                      Queue q = s.getQueue("queue1");
72                      assertEquals(0, q.size());
73                      q.put("String1");
74                  }
75                  catch (Exception e)
76                  {
77                      // ignore, let test fail
78                  }
79              }
80          };
81          t.start();
82          latch.await();
83          long t0 = System.currentTimeMillis();
84          QueueSession s = mgr.getQueueSession();
85          Queue q = s.getQueue("queue1");
86          assertEquals(0, q.size());
87          Object o = q.take();
88          long t1 = System.currentTimeMillis();
89          t.join();
90          assertNotNull(o);
91          assertEquals("String1", o);
92          assertEquals(0, q.size());
93          assertTrue(t1 - t0 > 100);
94  
95          mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
96      }
97  
98      public void testTakePutRollbackPut() throws Exception
99      {
100         final TransactionalQueueManager mgr = createQueueManager();
101         mgr.start();
102 
103         final Latch latch = new Latch();
104 
105         Thread t = new Thread()
106         {
107             public void run()
108             {
109                 try
110                 {
111                     latch.countDown();
112                     Thread.sleep(200);
113                     QueueSession s = mgr.getQueueSession();
114                     Queue q = s.getQueue("queue1");
115                     assertEquals(0, q.size());
116                     s.begin();
117                     q.put("String1");
118                     s.rollback();
119                     s.begin();
120                     q.put("String2");
121                     s.commit();
122                 }
123                 catch (Exception e)
124                 {
125                     // ignore, let test fail
126                 }
127             }
128         };
129         t.start();
130         latch.await();
131         long t0 = System.currentTimeMillis();
132         QueueSession s = mgr.getQueueSession();
133         Queue q = s.getQueue("queue1");
134         assertEquals(0, q.size());
135         Object o = q.take();
136         long t1 = System.currentTimeMillis();
137         t.join();
138         assertNotNull(o);
139         assertEquals("String2", o);
140         assertEquals(0, q.size());
141         assertTrue(t1 - t0 > 100);
142 
143         mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
144     }
145 
146     public void testTakePutOverCapacity() throws Exception
147     {
148         final TransactionalQueueManager mgr = createQueueManager();
149         mgr.start();
150         mgr.setDefaultQueueConfiguration(new QueueConfiguration(2));
151 
152         final Latch latch = new Latch();
153 
154         Thread t = new Thread()
155         {
156             public void run()
157             {
158                 try
159                 {
160                     latch.await();
161                     Thread.sleep(200);
162                     QueueSession s = mgr.getQueueSession();
163                     Queue q = s.getQueue("queue1");
164                     Object o = q.take();
165                     assertEquals("String1", o);
166                 }
167                 catch (Exception e)
168                 {
169                     // ignore, let test fail
170                 }
171             }
172         };
173         t.start();
174         QueueSession s = mgr.getQueueSession();
175         Queue q = s.getQueue("queue1");
176         assertEquals(0, q.size());
177         q.put("String1");
178         q.put("String2");
179         latch.countDown();
180         long t0 = System.currentTimeMillis();
181         q.put("String3");
182         long t1 = System.currentTimeMillis();
183         t.join();
184         assertEquals(2, q.size());
185         assertTrue(t1 - t0 > 100);
186 
187         mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
188     }
189 
190     public void testPutWithPersistence() throws Exception
191     {
192         if (isPersistent())
193         {
194             TransactionalQueueManager mgr = createQueueManager();
195 
196             try
197             {
198                 mgr.start();
199 
200                 QueueSession s = mgr.getQueueSession();
201                 Queue q = s.getQueue("queue1");
202                 q.put("String1");
203                 assertEquals(1, q.size());
204 
205                 q = s.getQueue("queue1");
206                 assertEquals(1, q.size());
207             }
208             finally
209             {
210                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
211             }
212 
213             mgr = createQueueManager();
214             try
215             {
216                 mgr.start();
217                 QueueSession s = mgr.getQueueSession();
218                 Queue q = s.getQueue("queue1");
219                 assertEquals(1, q.size());
220             }
221             finally
222             {
223                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
224             }
225         }
226         else
227         {
228             logger.info("Ignoring test because queue manager is not persistent");
229         }
230     }
231 
232     public void testTransactedPutCommitWithPersistence() throws Exception
233     {
234         if (isPersistent())
235         {
236             TransactionalQueueManager mgr = createQueueManager();
237 
238             try
239             {
240                 mgr.start();
241 
242                 QueueSession s = mgr.getQueueSession();
243                 Queue q = s.getQueue("queue1");
244                 s.begin();
245                 q.put("String1");
246                 assertEquals(1, q.size());
247                 s.commit();
248                 assertEquals(1, q.size());
249 
250                 s = mgr.getQueueSession();
251                 q = s.getQueue("queue1");
252                 assertEquals(1, q.size());
253 
254                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
255 
256                 mgr = createQueueManager();
257                 mgr.start();
258                 s = mgr.getQueueSession();
259                 q = s.getQueue("queue1");
260                 assertEquals(1, q.size());
261             }
262             finally
263             {
264                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
265             }
266         }
267         else
268         {
269             logger.info("Ignoring test because queue manager is not persistent");
270         }
271     }
272 
273     public void testTransactedPutRollbackWithPersistence() throws Exception
274     {
275         if (isPersistent())
276         {
277             TransactionalQueueManager mgr = createQueueManager();
278 
279             try
280             {
281                 mgr.start();
282 
283                 QueueSession s = mgr.getQueueSession();
284                 Queue q = s.getQueue("queue1");
285                 s.begin();
286                 q.put("String1");
287                 assertEquals(1, q.size());
288                 s.rollback();
289                 assertEquals(0, q.size());
290 
291                 s = mgr.getQueueSession();
292                 q = s.getQueue("queue1");
293                 assertEquals(0, q.size());
294 
295                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
296 
297                 mgr = createQueueManager();
298                 mgr.start();
299                 s = mgr.getQueueSession();
300                 q = s.getQueue("queue1");
301                 assertEquals(0, q.size());
302 
303             }
304             finally
305             {
306 
307                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
308 
309             }
310         }
311         else
312         {
313             logger.info("Ignoring test because queue manager is not persistent");
314         }
315     }
316 
317     public void testTransactionsOnMultipleQueues() throws Exception
318     {
319 
320         TransactionalQueueManager mgr = createQueueManager();
321 
322         try
323         {
324             mgr.start();
325 
326             QueueSession s1 = mgr.getQueueSession();
327             QueueSession s2 = mgr.getQueueSession();
328 
329             Queue q1s1 = s1.getQueue("queue1");
330             Queue q1s2 = s2.getQueue("queue1");
331             Queue q2s1 = s1.getQueue("queue2");
332             Queue q2s2 = s2.getQueue("queue2");
333 
334             q1s1.put("String1");
335             assertEquals(1, q1s1.size());
336             assertEquals(1, q1s2.size());
337 
338             s1.begin();
339 
340             Object o = q1s1.take();
341             assertNotNull(o);
342             assertEquals("String1", o);
343             assertEquals(0, q1s1.size());
344             assertEquals(0, q1s2.size());
345             q2s1.put("String2");
346             assertEquals(1, q2s1.size());
347             assertEquals(0, q2s2.size());
348 
349             s1.commit();
350 
351             assertEquals(0, q1s1.size());
352             assertEquals(0, q1s2.size());
353             assertEquals(1, q2s1.size());
354             assertEquals(1, q2s2.size());
355 
356             s1.begin();
357 
358             o = q2s1.take();
359             assertNotNull(o);
360             assertEquals("String2", o);
361             assertEquals(0, q1s1.size());
362             assertEquals(0, q1s2.size());
363             assertEquals(0, q2s1.size());
364             assertEquals(0, q2s2.size());
365 
366             q1s1.put("String1");
367 
368             assertEquals(1, q1s1.size());
369             assertEquals(0, q1s2.size());
370             assertEquals(0, q2s1.size());
371             assertEquals(0, q2s2.size());
372 
373             s1.rollback();
374 
375             assertEquals(0, q1s1.size());
376             assertEquals(0, q1s2.size());
377             assertEquals(1, q2s1.size());
378             assertEquals(1, q2s2.size());
379 
380         }
381         finally
382         {
383             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
384         }
385     }
386 
387     public void testPoll() throws Exception
388     {
389 
390         final TransactionalQueueManager mgr = createQueueManager();
391 
392         try
393         {
394             mgr.start();
395 
396             QueueSession s = mgr.getQueueSession();
397             Queue q = s.getQueue("queue1");
398 
399             assertEquals(q.size(), 0);
400             Object o = q.poll(0);
401             assertEquals(q.size(), 0);
402             assertNull(o);
403             o = q.poll(1000);
404             assertEquals(q.size(), 0);
405             assertNull(o);
406             q.put("String1");
407             assertEquals(q.size(), 1);
408             o = q.poll(0);
409             assertEquals(q.size(), 0);
410             assertEquals("String1", o);
411 
412             new Thread(new Runnable()
413             {
414                 public void run()
415                 {
416                     try
417                     {
418                         Thread.sleep(500);
419                         QueueSession s = mgr.getQueueSession();
420                         Queue q = s.getQueue("queue1");
421                         q.put("String1");
422                     }
423                     catch (Exception e)
424                     {
425                         e.printStackTrace();
426                     }
427                 }
428             }).start();
429             o = q.poll(1000);
430             assertEquals(q.size(), 0);
431             assertEquals("String1", o);
432 
433         }
434         finally
435         {
436             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
437         }
438     }
439 
440     public void testPeek() throws Exception
441     {
442 
443         TransactionalQueueManager mgr = createQueueManager();
444 
445         try
446         {
447             mgr.start();
448 
449             QueueSession s = mgr.getQueueSession();
450             Queue q = s.getQueue("queue1");
451 
452             assertEquals(q.size(), 0);
453             Object o = q.peek();
454             assertEquals(q.size(), 0);
455             assertNull(o);
456             q.put("String1");
457             assertEquals(q.size(), 1);
458             o = q.peek();
459             assertEquals(q.size(), 1);
460             assertEquals("String1", o);
461 
462         }
463         finally
464         {
465             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
466         }
467     }
468 
469     public void testOffer() throws Exception
470     {
471 
472         final TransactionalQueueManager mgr = createQueueManager();
473         mgr.setDefaultQueueConfiguration(new QueueConfiguration(1));
474         try
475         {
476             mgr.start();
477 
478             QueueSession s = mgr.getQueueSession();
479             Queue q = s.getQueue("queue1");
480 
481             assertEquals(q.size(), 0);
482             assertTrue(q.offer("String1", 0L));
483             assertEquals(q.size(), 1);
484             assertFalse(q.offer("String2", 1000));
485             assertEquals(q.size(), 1);
486 
487             new Thread(new Runnable()
488             {
489                 public void run()
490                 {
491                     try
492                     {
493                         Thread.sleep(500);
494                         QueueSession s = mgr.getQueueSession();
495                         Queue q = s.getQueue("queue1");
496                         assertEquals("String1", q.take());
497                     }
498                     catch (Exception e)
499                     {
500                         e.printStackTrace();
501                     }
502                 }
503             }).start();
504             assertTrue(q.offer("String2", 1000));
505             assertEquals(q.size(), 1);
506         }
507         finally
508         {
509             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
510         }
511     }
512 
513     public void testBench() throws Exception
514     {
515 
516         TransactionalQueueManager mgr = createQueueManager();
517 
518         try
519         {
520             mgr.start();
521 
522             QueueSession s = mgr.getQueueSession();
523             Queue q = s.getQueue("queue1");
524 
525             Random rnd = new Random();
526             long t0 = System.currentTimeMillis();
527             for (int i = 0; i < 1; i++)
528             {
529                 for (int j = 0; j < 500; j++)
530                 {
531                     byte[] o = new byte[2048];
532                     rnd.nextBytes(o);
533                     q.put(o);
534                 }
535                 while (q.size() > 0)
536                 {
537                     q.take();
538                 }
539             }
540             long t1 = System.currentTimeMillis();
541 
542             logger.info("Time: " + (t1 - t0) + " ms");
543 
544         }
545         finally
546         {
547             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
548         }
549     }
550 
551 }