View Javadoc

1   /*
2    * $Id: AbstractTransactionQueueManagerTestCase.java 19191 2010-08-25 21:05:23Z tcarlson $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.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("Queue size", 0, q.size());
43          q.put("String1");
44          assertEquals("Queue size", 1, q.size());
45          Object o = q.take();
46          assertNotNull(o);
47          assertEquals("Queue content", "String1", o);
48          assertEquals("Queue size", 0, q.size());
49  
50          purgeQueue(q);
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              @Override
65              public void run()
66              {
67                  try
68                  {
69                      latch.countDown();
70                      Thread.sleep(200);
71                      QueueSession s = mgr.getQueueSession();
72                      Queue q = s.getQueue("queue1");
73                      assertEquals("Queue size", 0, q.size());
74                      q.put("String1");
75                  }
76                  catch (Exception e)
77                  {
78                      // ignore, let test fail
79                  }
80              }
81          };
82          t.start();
83          latch.await();
84          long t0 = System.currentTimeMillis();
85          QueueSession s = mgr.getQueueSession();
86          Queue q = s.getQueue("queue1");
87          assertEquals("Queue size", 0, q.size());
88          Object o = q.take();
89          long t1 = System.currentTimeMillis();
90          t.join();
91          assertNotNull(o);
92          assertEquals("Queue content", "String1", o);
93          assertEquals("Queue size", 0, q.size());
94          assertTrue(t1 - t0 > 100);
95  
96          purgeQueue(q);
97          
98          mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
99      }
100 
101     public void testTakePutRollbackPut() throws Exception
102     {
103         final TransactionalQueueManager mgr = createQueueManager();
104         mgr.start();
105 
106         final Latch latch = new Latch();
107 
108         Thread t = new Thread()
109         {
110             @Override
111             public void run()
112             {
113                 try
114                 {
115                     latch.countDown();
116                     Thread.sleep(200);
117                     QueueSession s = mgr.getQueueSession();
118                     Queue q = s.getQueue("queue1");
119                     assertEquals("Queue size", 0, q.size());
120                     s.begin();
121                     q.put("String1");
122                     s.rollback();
123                     s.begin();
124                     q.put("String2");
125                     s.commit();
126                 }
127                 catch (Exception e)
128                 {
129                     // ignore, let test fail
130                 }
131             }
132         };
133         t.start();
134         latch.await();
135         long t0 = System.currentTimeMillis();
136         QueueSession s = mgr.getQueueSession();
137         Queue q = s.getQueue("queue1");
138         assertEquals("Queue size", 0, q.size());
139         Object o = q.take();
140         long t1 = System.currentTimeMillis();
141         t.join();
142         assertNotNull(o);
143         assertEquals("Queue content", "String2", o);
144         assertEquals("Queue size", 0, q.size());
145         assertTrue(t1 - t0 > 100);
146 
147         purgeQueue(q);
148         
149         mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
150     }
151 
152     public void testTakePutOverCapacity() throws Exception
153     {
154         final TransactionalQueueManager mgr = createQueueManager();
155         mgr.start();
156         mgr.setDefaultQueueConfiguration(new QueueConfiguration(2));
157 
158         final Latch latch = new Latch();
159 
160         Thread t = new Thread()
161         {
162             @Override
163             public void run()
164             {
165                 try
166                 {
167                     latch.await();
168                     Thread.sleep(200);
169                     QueueSession s = mgr.getQueueSession();
170                     Queue q = s.getQueue("queue1");
171                     Object o = q.take();
172                     assertEquals("Queue content", "String1", o);
173                 }
174                 catch (Exception e)
175                 {
176                     // ignore, let test fail
177                 }
178             }
179         };
180         t.start();
181         QueueSession s = mgr.getQueueSession();
182         Queue q = s.getQueue("queue1");
183         assertEquals("Queue size", 0, q.size());
184         q.put("String1");
185         q.put("String2");
186         latch.countDown();
187         long t0 = System.currentTimeMillis();
188         q.put("String3");
189         long t1 = System.currentTimeMillis();
190         t.join();
191         assertEquals("Queue size", 2, q.size());
192         assertTrue(t1 - t0 > 100);
193 
194         purgeQueue(q);
195         
196         mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
197     }
198 
199     public void testPutWithPersistence() throws Exception
200     {
201         if (isPersistent())
202         {
203             TransactionalQueueManager mgr = createQueueManager();
204 
205             try
206             {
207                 mgr.start();
208 
209                 QueueSession s = mgr.getQueueSession();
210                 Queue q = s.getQueue("queue1");
211                 q.put("String1");
212                 assertEquals("Queue size", 1, q.size());
213 
214                 q = s.getQueue("queue1");
215                 assertEquals("Queue size", 1, q.size());
216             }
217             finally
218             {
219                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
220             }
221 
222             mgr = createQueueManager();
223             try
224             {
225                 mgr.start();
226                 QueueSession s = mgr.getQueueSession();
227                 Queue q = s.getQueue("queue1");
228                 assertEquals("Queue size", 1, q.size());
229                 
230                 purgeQueue(q);
231             }
232             finally
233             {
234                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
235             }
236         }
237         else
238         {
239             logger.info("Ignoring test because queue manager is not persistent");
240         }
241     }
242 
243     public void testTransactedPutCommitWithPersistence() throws Exception
244     {
245         if (isPersistent())
246         {
247             TransactionalQueueManager mgr = createQueueManager();
248 
249             try
250             {
251                 mgr.start();
252 
253                 QueueSession s = mgr.getQueueSession();
254                 Queue q = s.getQueue("queue1");
255                 s.begin();
256                 q.put("String1");
257                 assertEquals("Queue size", 1, q.size());
258                 s.commit();
259                 assertEquals("Queue size", 1, q.size());
260 
261                 s = mgr.getQueueSession();
262                 q = s.getQueue("queue1");
263                 assertEquals("Queue size", 1, q.size());
264 
265                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
266 
267                 mgr = createQueueManager();
268                 mgr.start();
269                 s = mgr.getQueueSession();
270                 q = s.getQueue("queue1");
271                 assertEquals("Queue size", 1, q.size());
272 
273                 purgeQueue(q);
274             }
275             finally
276             {
277                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
278             }
279         }
280         else
281         {
282             logger.info("Ignoring test because queue manager is not persistent");
283         }
284     }
285 
286     public void testTransactedPutRollbackWithPersistence() throws Exception
287     {
288         if (isPersistent())
289         {
290             TransactionalQueueManager mgr = createQueueManager();
291 
292             try
293             {
294                 mgr.start();
295 
296                 QueueSession s = mgr.getQueueSession();
297                 Queue q = s.getQueue("queue1");
298                 s.begin();
299                 q.put("String1");
300                 assertEquals("Queue size", 1, q.size());
301                 s.rollback();
302                 assertEquals("Queue size", 0, q.size());
303 
304                 s = mgr.getQueueSession();
305                 q = s.getQueue("queue1");
306                 assertEquals("Queue size", 0, q.size());
307 
308                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
309 
310                 mgr = createQueueManager();
311                 mgr.start();
312                 s = mgr.getQueueSession();
313                 q = s.getQueue("queue1");
314                 assertEquals("Queue size", 0, q.size());
315 
316                 purgeQueue(q);
317             }
318             finally
319             {
320 
321                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
322 
323             }
324         }
325         else
326         {
327             logger.info("Ignoring test because queue manager is not persistent");
328         }
329     }
330 
331     public void testPutTake_RespectsOrderOnPersistence() throws Exception
332     {
333         if (isPersistent())
334         {
335             TransactionalQueueManager mgr1 = createQueueManager();
336             mgr1.start();
337 
338             QueueSession s1 = mgr1.getQueueSession();
339             Queue q1 = s1.getQueue("queue1");
340 
341             assertEquals("Queue size", 0, q1.size());
342             final int numberOfElements = 10;
343             for (int i = 1; i <= numberOfElements; i++)
344             {
345                 q1.put("String" + i);
346                 assertEquals("Queue size", i, q1.size());
347             }
348 
349             mgr1.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
350 
351             TransactionalQueueManager mgr2 = createQueueManager();
352             mgr2.start();
353 
354             QueueSession s2 = mgr2.getQueueSession();
355             Queue q2 = s2.getQueue("queue1");
356 
357             for (int i = 1; i <= numberOfElements; i++)
358             {
359                 Object o = q2.take();
360                 assertNotNull(o);
361                 assertEquals("Queue content", "String" + i, o);
362             }
363             assertEquals("Queue size", 0, q2.size());
364 
365             purgeQueue(q2);
366 
367             mgr2.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
368         }
369     }
370 
371     public void testTransactionsOnMultipleQueues() throws Exception
372     {
373 
374         TransactionalQueueManager mgr = createQueueManager();
375 
376         try
377         {
378             mgr.start();
379 
380             QueueSession s1 = mgr.getQueueSession();
381             QueueSession s2 = mgr.getQueueSession();
382 
383             Queue q1s1 = s1.getQueue("queue1");
384             Queue q1s2 = s2.getQueue("queue1");
385             Queue q2s1 = s1.getQueue("queue2");
386             Queue q2s2 = s2.getQueue("queue2");
387 
388             q1s1.put("String1");
389             assertEquals("Queue size", 1, q1s1.size());
390             assertEquals("Queue size", 1, q1s2.size());
391 
392             s1.begin();
393 
394             Object o = q1s1.take();
395             assertNotNull(o);
396             assertEquals("String1", o);
397             assertEquals("Queue size", 0, q1s1.size());
398             assertEquals("Queue size", 0, q1s2.size());
399             q2s1.put("String2");
400             assertEquals("Queue size", 1, q2s1.size());
401             assertEquals("Queue size", 0, q2s2.size());
402 
403             s1.commit();
404 
405             assertEquals("Queue size", 0, q1s1.size());
406             assertEquals("Queue size", 0, q1s2.size());
407             assertEquals("Queue size", 1, q2s1.size());
408             assertEquals("Queue size", 1, q2s2.size());
409 
410             s1.begin();
411 
412             o = q2s1.take();
413             assertNotNull(o);
414             assertEquals("String2", o);
415             assertEquals("Queue size", 0, q1s1.size());
416             assertEquals("Queue size", 0, q1s2.size());
417             assertEquals("Queue size", 0, q2s1.size());
418             assertEquals("Queue size", 0, q2s2.size());
419 
420             q1s1.put("String1");
421 
422             assertEquals("Queue size", 1, q1s1.size());
423             assertEquals("Queue size", 0, q1s2.size());
424             assertEquals("Queue size", 0, q2s1.size());
425             assertEquals("Queue size", 0, q2s2.size());
426 
427             s1.rollback();
428 
429             assertEquals("Queue size", 0, q1s1.size());
430             assertEquals("Queue size", 0, q1s2.size());
431             assertEquals("Queue size", 1, q2s1.size());
432             assertEquals("Queue size", 1, q2s2.size());
433             
434             purgeQueue(q1s1);
435             purgeQueue(q1s2);
436             purgeQueue(q2s1);
437             purgeQueue(q2s2);
438         }
439         finally
440         {
441             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
442         }
443     }
444 
445     public void testPoll() throws Exception
446     {
447 
448         final TransactionalQueueManager mgr = createQueueManager();
449 
450         try
451         {
452             mgr.start();
453 
454             QueueSession s = mgr.getQueueSession();
455             Queue q = s.getQueue("queue1");
456 
457             assertEquals("Queue size", 0, q.size());
458             Object o = q.poll(0);
459             assertEquals("Queue size", 0, q.size());
460             assertNull(o);
461             o = q.poll(1000);
462             assertEquals("Queue size", 0, q.size());
463             assertNull(o);
464             q.put("String1");
465             assertEquals("Queue size", 1, q.size());
466             o = q.poll(0);
467             assertEquals("Queue size", 0, q.size());
468             assertEquals("Queue content", "String1", o);
469 
470             new Thread(new Runnable()
471             {
472                 public void run()
473                 {
474                     try
475                     {
476                         Thread.sleep(500);
477                         QueueSession s = mgr.getQueueSession();
478                         Queue q = s.getQueue("queue1");
479                         q.put("String1");
480                     }
481                     catch (Exception e)
482                     {
483                         e.printStackTrace();
484                     }
485                 }
486             }).start();
487             o = q.poll(1000);
488             assertEquals("Queue size", q.size(), 0);
489             assertEquals("Queue content", "String1", o);
490         
491             purgeQueue(q);
492         }
493         finally
494         {
495             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
496         }
497     }
498 
499     public void testPeek() throws Exception
500     {
501 
502         TransactionalQueueManager mgr = createQueueManager();
503 
504         try
505         {
506             mgr.start();
507 
508             QueueSession s = mgr.getQueueSession();
509             Queue q = s.getQueue("queue1");
510 
511             assertEquals("Queue size", 0, q.size());
512             Object o = q.peek();
513             assertEquals("Queue size", 0, q.size());
514             assertNull(o);
515             q.put("String1");
516             assertEquals("Queue size", 1, q.size());
517             o = q.peek();
518             assertEquals("Queue size", 1, q.size());
519             assertEquals("Queue content", "String1", o);
520             o = q.poll(1000);
521             assertEquals("Queue size", 0, q.size());
522             assertEquals("Queue content", "String1", o);
523             
524             purgeQueue(q);
525         }
526         finally
527         {
528             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
529         }
530     }
531 
532     public void testOffer() throws Exception
533     {
534 
535         final TransactionalQueueManager mgr = createQueueManager();
536         mgr.setDefaultQueueConfiguration(new QueueConfiguration(1));
537         try
538         {
539             mgr.start();
540 
541             QueueSession s = mgr.getQueueSession();
542             Queue q = s.getQueue("queue1");
543 
544             assertEquals("Queue size", 0, q.size());
545             assertTrue(q.offer("String1", 0L));
546             assertEquals("Queue size", 1, q.size());
547             assertFalse(q.offer("String2", 1000));
548             assertEquals("Queue size", 1, q.size());
549 
550             new Thread(new Runnable()
551             {
552                 public void run()
553                 {
554                     try
555                     {
556                         Thread.sleep(500);
557                         QueueSession s = mgr.getQueueSession();
558                         Queue q = s.getQueue("queue1");
559                         assertEquals("Queue content", "String1", q.take());
560                     }
561                     catch (Exception e)
562                     {
563                         e.printStackTrace();
564                     }
565                 }
566             }).start();
567             assertTrue(q.offer("String2", 1000));
568             assertEquals("Queue size", 1, q.size());
569             
570             purgeQueue(q);
571         }
572         finally
573         {
574             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
575         }
576     }
577 
578     public void testBench() throws Exception
579     {
580 
581         TransactionalQueueManager mgr = createQueueManager();
582 
583         try
584         {
585             mgr.start();
586 
587             QueueSession s = mgr.getQueueSession();
588             Queue q = s.getQueue("queue1");
589 
590             Random rnd = new Random();
591             long t0 = System.currentTimeMillis();
592             for (int i = 0; i < 1; i++)
593             {
594                 for (int j = 0; j < 500; j++)
595                 {
596                     byte[] o = new byte[2048];
597                     rnd.nextBytes(o);
598                     q.put(o);
599                 }
600                 while (q.size() > 0)
601                 {
602                     q.take();
603                 }
604             }
605             long t1 = System.currentTimeMillis();
606 
607             logger.info("Time: " + (t1 - t0) + " ms");
608             
609             purgeQueue(q);
610         }
611         finally
612         {
613             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
614         }
615     }
616     
617     protected void purgeQueue(Queue queue) throws InterruptedException
618     {
619         while(queue.size() > 0)
620         {
621             queue.poll(1000);
622         }
623         assertEquals("Queue must be fully consumed after successful test run. Queue size:", 0, queue.size());
624     }
625 
626     public void testRecoverWarmRestart() throws Exception
627     {
628         TransactionalQueueManager mgr = createQueueManager();
629         mgr.start();
630         QueueSession s = mgr.getQueueSession();
631         Queue q = s.getQueue("warmRecoverQueue");
632 
633         int toPopulate = 500;
634 
635         // Populate queue
636         Random rnd = new Random();
637         for (int j = 0; j < toPopulate; j++)
638         {
639             byte[] o = new byte[2048];
640             rnd.nextBytes(o);
641             q.put(o);
642         }
643         assertEquals(q.size(), toPopulate);
644 
645         // Stop and start TransactionalQueueManager
646         mgr.stop();
647         mgr.start();
648 
649         assertEquals(toPopulate, q.size());
650     }
651 
652     public void testRecoverColdRestart() throws Exception
653     {
654         TransactionalQueueManager mgr = createQueueManager();
655         mgr.start();
656         QueueSession s = mgr.getQueueSession();
657         Queue q = s.getQueue("warmRecoverQueue");
658 
659         int toPopulate = 500;
660 
661         // Populate queue
662         Random rnd = new Random();
663         for (int j = 0; j < toPopulate; j++)
664         {
665             byte[] o = new byte[2048];
666             rnd.nextBytes(o);
667             q.put(o);
668         }
669         assertEquals(toPopulate, q.size());
670 
671         // Stop and recreate TransactionalQueueManager simulating a cold restart
672         mgr.stop();
673         mgr = createQueueManager();
674         mgr.start();
675         s = mgr.getQueueSession();
676         q = s.getQueue("warmRecoverQueue");
677 
678         if (isPersistent())
679         {
680             assertEquals(toPopulate, q.size());
681         }
682         else
683         {
684             assertEquals(0, q.size());
685         }
686 
687     }
688     
689 }