1
2
3
4
5
6
7
8
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
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
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
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
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
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
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
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
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 }