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