1   /*
2    * $Id: AbstractTransactionQueueManagerTestCase.java 11635 2008-04-23 19:10:09Z aguenther $
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("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              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("Queue size", 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("Queue size", 0, q.size());
87          Object o = q.take();
88          long t1 = System.currentTimeMillis();
89          t.join();
90          assertNotNull(o);
91          assertEquals("Queue content", "String1", o);
92          assertEquals("Queue size", 0, q.size());
93          assertTrue(t1 - t0 > 100);
94  
95          purgeQueue(q);
96          
97          mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
98      }
99  
100     public void testTakePutRollbackPut() throws Exception
101     {
102         final TransactionalQueueManager mgr = createQueueManager();
103         mgr.start();
104 
105         final Latch latch = new Latch();
106 
107         Thread t = new Thread()
108         {
109             public void run()
110             {
111                 try
112                 {
113                     latch.countDown();
114                     Thread.sleep(200);
115                     QueueSession s = mgr.getQueueSession();
116                     Queue q = s.getQueue("queue1");
117                     assertEquals("Queue size", 0, q.size());
118                     s.begin();
119                     q.put("String1");
120                     s.rollback();
121                     s.begin();
122                     q.put("String2");
123                     s.commit();
124                 }
125                 catch (Exception e)
126                 {
127                     // ignore, let test fail
128                 }
129             }
130         };
131         t.start();
132         latch.await();
133         long t0 = System.currentTimeMillis();
134         QueueSession s = mgr.getQueueSession();
135         Queue q = s.getQueue("queue1");
136         assertEquals("Queue size", 0, q.size());
137         Object o = q.take();
138         long t1 = System.currentTimeMillis();
139         t.join();
140         assertNotNull(o);
141         assertEquals("Queue content", "String2", o);
142         assertEquals("Queue size", 0, q.size());
143         assertTrue(t1 - t0 > 100);
144 
145         purgeQueue(q);
146         
147         mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
148     }
149 
150     public void testTakePutOverCapacity() throws Exception
151     {
152         final TransactionalQueueManager mgr = createQueueManager();
153         mgr.start();
154         mgr.setDefaultQueueConfiguration(new QueueConfiguration(2));
155 
156         final Latch latch = new Latch();
157 
158         Thread t = new Thread()
159         {
160             public void run()
161             {
162                 try
163                 {
164                     latch.await();
165                     Thread.sleep(200);
166                     QueueSession s = mgr.getQueueSession();
167                     Queue q = s.getQueue("queue1");
168                     Object o = q.take();
169                     assertEquals("Queue content", "String1", o);
170                 }
171                 catch (Exception e)
172                 {
173                     // ignore, let test fail
174                 }
175             }
176         };
177         t.start();
178         QueueSession s = mgr.getQueueSession();
179         Queue q = s.getQueue("queue1");
180         assertEquals("Queue size", 0, q.size());
181         q.put("String1");
182         q.put("String2");
183         latch.countDown();
184         long t0 = System.currentTimeMillis();
185         q.put("String3");
186         long t1 = System.currentTimeMillis();
187         t.join();
188         assertEquals("Queue size", 2, q.size());
189         assertTrue(t1 - t0 > 100);
190 
191         purgeQueue(q);
192         
193         mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
194     }
195 
196     public void testPutWithPersistence() throws Exception
197     {
198         if (isPersistent())
199         {
200             TransactionalQueueManager mgr = createQueueManager();
201 
202             try
203             {
204                 mgr.start();
205 
206                 QueueSession s = mgr.getQueueSession();
207                 Queue q = s.getQueue("queue1");
208                 q.put("String1");
209                 assertEquals("Queue size", 1, q.size());
210 
211                 q = s.getQueue("queue1");
212                 assertEquals("Queue size", 1, q.size());
213             }
214             finally
215             {
216                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
217             }
218 
219             mgr = createQueueManager();
220             try
221             {
222                 mgr.start();
223                 QueueSession s = mgr.getQueueSession();
224                 Queue q = s.getQueue("queue1");
225                 assertEquals("Queue size", 1, q.size());
226                 
227                 purgeQueue(q);
228             }
229             finally
230             {
231                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
232             }
233         }
234         else
235         {
236             logger.info("Ignoring test because queue manager is not persistent");
237         }
238     }
239 
240     public void testTransactedPutCommitWithPersistence() throws Exception
241     {
242         if (isPersistent())
243         {
244             TransactionalQueueManager mgr = createQueueManager();
245 
246             try
247             {
248                 mgr.start();
249 
250                 QueueSession s = mgr.getQueueSession();
251                 Queue q = s.getQueue("queue1");
252                 s.begin();
253                 q.put("String1");
254                 assertEquals("Queue size", 1, q.size());
255                 s.commit();
256                 assertEquals("Queue size", 1, q.size());
257 
258                 s = mgr.getQueueSession();
259                 q = s.getQueue("queue1");
260                 assertEquals("Queue size", 1, q.size());
261 
262                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
263 
264                 mgr = createQueueManager();
265                 mgr.start();
266                 s = mgr.getQueueSession();
267                 q = s.getQueue("queue1");
268                 assertEquals("Queue size", 1, q.size());
269 
270                 purgeQueue(q);
271             }
272             finally
273             {
274                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
275             }
276         }
277         else
278         {
279             logger.info("Ignoring test because queue manager is not persistent");
280         }
281     }
282 
283     public void testTransactedPutRollbackWithPersistence() throws Exception
284     {
285         if (isPersistent())
286         {
287             TransactionalQueueManager mgr = createQueueManager();
288 
289             try
290             {
291                 mgr.start();
292 
293                 QueueSession s = mgr.getQueueSession();
294                 Queue q = s.getQueue("queue1");
295                 s.begin();
296                 q.put("String1");
297                 assertEquals("Queue size", 1, q.size());
298                 s.rollback();
299                 assertEquals("Queue size", 0, q.size());
300 
301                 s = mgr.getQueueSession();
302                 q = s.getQueue("queue1");
303                 assertEquals("Queue size", 0, q.size());
304 
305                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
306 
307                 mgr = createQueueManager();
308                 mgr.start();
309                 s = mgr.getQueueSession();
310                 q = s.getQueue("queue1");
311                 assertEquals("Queue size", 0, q.size());
312 
313                 purgeQueue(q);
314             }
315             finally
316             {
317 
318                 mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
319 
320             }
321         }
322         else
323         {
324             logger.info("Ignoring test because queue manager is not persistent");
325         }
326     }
327 
328     public void testTransactionsOnMultipleQueues() throws Exception
329     {
330 
331         TransactionalQueueManager mgr = createQueueManager();
332 
333         try
334         {
335             mgr.start();
336 
337             QueueSession s1 = mgr.getQueueSession();
338             QueueSession s2 = mgr.getQueueSession();
339 
340             Queue q1s1 = s1.getQueue("queue1");
341             Queue q1s2 = s2.getQueue("queue1");
342             Queue q2s1 = s1.getQueue("queue2");
343             Queue q2s2 = s2.getQueue("queue2");
344 
345             q1s1.put("String1");
346             assertEquals("Queue size", 1, q1s1.size());
347             assertEquals("Queue size", 1, q1s2.size());
348 
349             s1.begin();
350 
351             Object o = q1s1.take();
352             assertNotNull(o);
353             assertEquals("String1", o);
354             assertEquals("Queue size", 0, q1s1.size());
355             assertEquals("Queue size", 0, q1s2.size());
356             q2s1.put("String2");
357             assertEquals("Queue size", 1, q2s1.size());
358             assertEquals("Queue size", 0, q2s2.size());
359 
360             s1.commit();
361 
362             assertEquals("Queue size", 0, q1s1.size());
363             assertEquals("Queue size", 0, q1s2.size());
364             assertEquals("Queue size", 1, q2s1.size());
365             assertEquals("Queue size", 1, q2s2.size());
366 
367             s1.begin();
368 
369             o = q2s1.take();
370             assertNotNull(o);
371             assertEquals("String2", o);
372             assertEquals("Queue size", 0, q1s1.size());
373             assertEquals("Queue size", 0, q1s2.size());
374             assertEquals("Queue size", 0, q2s1.size());
375             assertEquals("Queue size", 0, q2s2.size());
376 
377             q1s1.put("String1");
378 
379             assertEquals("Queue size", 1, q1s1.size());
380             assertEquals("Queue size", 0, q1s2.size());
381             assertEquals("Queue size", 0, q2s1.size());
382             assertEquals("Queue size", 0, q2s2.size());
383 
384             s1.rollback();
385 
386             assertEquals("Queue size", 0, q1s1.size());
387             assertEquals("Queue size", 0, q1s2.size());
388             assertEquals("Queue size", 1, q2s1.size());
389             assertEquals("Queue size", 1, q2s2.size());
390             
391             purgeQueue(q1s1);
392             purgeQueue(q1s2);
393             purgeQueue(q2s1);
394             purgeQueue(q2s2);
395         }
396         finally
397         {
398             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
399         }
400     }
401 
402     public void testPoll() throws Exception
403     {
404 
405         final TransactionalQueueManager mgr = createQueueManager();
406 
407         try
408         {
409             mgr.start();
410 
411             QueueSession s = mgr.getQueueSession();
412             Queue q = s.getQueue("queue1");
413 
414             assertEquals("Queue size", 0, q.size());
415             Object o = q.poll(0);
416             assertEquals("Queue size", 0, q.size());
417             assertNull(o);
418             o = q.poll(1000);
419             assertEquals("Queue size", 0, q.size());
420             assertNull(o);
421             q.put("String1");
422             assertEquals("Queue size", 1, q.size());
423             o = q.poll(0);
424             assertEquals("Queue size", 0, q.size());
425             assertEquals("Queue content", "String1", o);
426 
427             new Thread(new Runnable()
428             {
429                 public void run()
430                 {
431                     try
432                     {
433                         Thread.sleep(500);
434                         QueueSession s = mgr.getQueueSession();
435                         Queue q = s.getQueue("queue1");
436                         q.put("String1");
437                     }
438                     catch (Exception e)
439                     {
440                         e.printStackTrace();
441                     }
442                 }
443             }).start();
444             o = q.poll(1000);
445             assertEquals("Queue size", q.size(), 0);
446             assertEquals("Queue content", "String1", o);
447         
448             purgeQueue(q);
449         }
450         finally
451         {
452             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
453         }
454     }
455 
456     public void testPeek() throws Exception
457     {
458 
459         TransactionalQueueManager mgr = createQueueManager();
460 
461         try
462         {
463             mgr.start();
464 
465             QueueSession s = mgr.getQueueSession();
466             Queue q = s.getQueue("queue1");
467 
468             assertEquals("Queue size", 0, q.size());
469             Object o = q.peek();
470             assertEquals("Queue size", 0, q.size());
471             assertNull(o);
472             q.put("String1");
473             assertEquals("Queue size", 1, q.size());
474             o = q.peek();
475             assertEquals("Queue size", 1, q.size());
476             assertEquals("Queue content", "String1", o);
477             o = q.poll(1000);
478             assertEquals("Queue size", 0, q.size());
479             assertEquals("Queue content", "String1", o);
480             
481             purgeQueue(q);
482         }
483         finally
484         {
485             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
486         }
487     }
488 
489     public void testOffer() throws Exception
490     {
491 
492         final TransactionalQueueManager mgr = createQueueManager();
493         mgr.setDefaultQueueConfiguration(new QueueConfiguration(1));
494         try
495         {
496             mgr.start();
497 
498             QueueSession s = mgr.getQueueSession();
499             Queue q = s.getQueue("queue1");
500 
501             assertEquals("Queue size", 0, q.size());
502             assertTrue(q.offer("String1", 0L));
503             assertEquals("Queue size", 1, q.size());
504             assertFalse(q.offer("String2", 1000));
505             assertEquals("Queue size", 1, q.size());
506 
507             new Thread(new Runnable()
508             {
509                 public void run()
510                 {
511                     try
512                     {
513                         Thread.sleep(500);
514                         QueueSession s = mgr.getQueueSession();
515                         Queue q = s.getQueue("queue1");
516                         assertEquals("Queue content", "String1", q.take());
517                     }
518                     catch (Exception e)
519                     {
520                         e.printStackTrace();
521                     }
522                 }
523             }).start();
524             assertTrue(q.offer("String2", 1000));
525             assertEquals("Queue size", 1, q.size());
526             
527             purgeQueue(q);
528         }
529         finally
530         {
531             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
532         }
533     }
534 
535     public void testBench() throws Exception
536     {
537 
538         TransactionalQueueManager mgr = createQueueManager();
539 
540         try
541         {
542             mgr.start();
543 
544             QueueSession s = mgr.getQueueSession();
545             Queue q = s.getQueue("queue1");
546 
547             Random rnd = new Random();
548             long t0 = System.currentTimeMillis();
549             for (int i = 0; i < 1; i++)
550             {
551                 for (int j = 0; j < 500; j++)
552                 {
553                     byte[] o = new byte[2048];
554                     rnd.nextBytes(o);
555                     q.put(o);
556                 }
557                 while (q.size() > 0)
558                 {
559                     q.take();
560                 }
561             }
562             long t1 = System.currentTimeMillis();
563 
564             logger.info("Time: " + (t1 - t0) + " ms");
565             
566             purgeQueue(q);
567         }
568         finally
569         {
570             mgr.stop(AbstractResourceManager.SHUTDOWN_MODE_NORMAL);
571         }
572     }
573     
574     protected void purgeQueue(Queue queue) throws InterruptedException
575     {
576         while(queue.size() > 0)
577         {
578             queue.poll(1000);
579         }
580         assertEquals("Queue must be fully consumed after successful test run. Queue size:", 0, queue.size());
581     }
582 
583 }