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 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
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
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
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 }