Package org.jboss.messaging.core.local

Examples of org.jboss.messaging.core.local.PagingFilteredQueue


      super.tearDown();
   }
  
   public void testChannelShareNP_2PC() throws Throwable
   {
      PagingFilteredQueue queue1 = new PagingFilteredQueue("queue1", 1, ms, pm, true, true, -1, null, 100, 20, 10);
     
      PagingFilteredQueue queue2 = new PagingFilteredQueue("queue2", 2, ms, pm, true, true, -1, null, 50, 10, 5);
    
      Message[] msgs = new Message[150];
     
      MessageReference[] refs1 = new MessageReference[150];
     
      MessageReference[] refs2 = new MessageReference[150];
     
      //Send 50 refs to both channels
     
      Transaction tx = this.createXATx();
      for (int i = 0; i < 50; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
       
      //Queue1
      List refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
      assertEquals(0, refIds.size());
                                   
      assertEquals(50, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
      
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(0, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
          
      //Msgs
     
      assertEquals(50, ms.size());
     
      List msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Add 25 more
     
      tx = this.createXATx();
      for (int i = 50; i < 75; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
        
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
      
      //Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
             
      assertEquals(0, refIds.size());
                                   
      assertEquals(75, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
       
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(25, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(75, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(25, msgIds.size());
      
      // Add 25 more
      tx = this.createXATx();
      for (int i = 75; i < 100; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);

         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
        
         refs1[i].releaseMemoryReference();

         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
        
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
     
      //Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(50, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(100, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(50, msgIds.size());
     
      // Add 50 more
      tx = this.createXATx();
      for (int i = 100; i < 150; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
        
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
        
      //Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
               
      assertEquals(50, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(100, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
              
      //Msgs
     
      assertEquals(100, ms.size());
       
      msgIds = getMessageIds();
      assertEquals(100, msgIds.size());
            
      cancelDeliveries(queue1, 100);
     
      cancelDeliveries(queue2, 100);
     

      //Now consume them all
     
      this.consumeIn2PCTx(queue1, 0, refs1, 150);
      
      this.consumeIn2PCTx(queue2, 0, refs2, 150);
     
      //    Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
                                   
      assertEquals(0, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
       
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(0, refIds.size());
                             
      assertEquals(0, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertFalse(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(0, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Should be none left
     
      assertEquals(0, queue1.getMessageCount());
     
      assertEquals(0, queue2.getMessageCount());
     
      assertEquals(0, LockMap.instance.getSize());
     
   }
View Full Code Here


      super.tearDown();
   }
  
   public void test1() throws Throwable
   {
      PagingFilteredQueue queue = new PagingFilteredQueue("queue1", 1, ms, pm, true, true, -1, null, 100, 20, 10);
     
      Message[] msgs = new Message[241];
     
      MessageReference[] refs = new MessageReference[241];
 
      //Send 99
     
      Transaction tx = tr.createTransaction();
      for (int i = 0; i < 99; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);
         refs[i].releaseMemoryReference();
      }
      tx.commit();
     
      //verify no unloaded refs in storage
           
      List refIds = getPagedReferenceIds(queue.getChannelID());
      assertTrue(refIds.isEmpty());
     
      //verify 99 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(99, refIds.size());
      assertSameIds(refIds, refs, 0, 98);
     
      //Verify 99 msgs in storage
      List msgIds = getMessageIds();
      assertEquals(99, msgIds.size());
      assertSameIds(msgIds, refs, 0, 98);
     
      //Verify 99 msgs in store
      assertEquals(99, ms.size());
     
      //Verify 99 refs in queue
      assertEquals(99, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
      //Send one more ref
     
      tx = tr.createTransaction();
      msgs[99] = CoreMessageFactory.createCoreMessage(99, true, null);
      refs[99] = ms.reference(msgs[99]);
      queue.handle(null, refs[99], tx);
      refs[99].releaseMemoryReference();
      tx.commit();
     
      //verify no unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertTrue(refIds.isEmpty());
     
      //verify 100 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(100, refIds.size());
      assertSameIds(refIds, refs, 0, 99);
     
      //Verify 100 msgs in storage
      msgIds = getMessageIds();
      assertEquals(100, msgIds.size());
      assertSameIds(msgIds, refs, 0, 99);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
           
      //Verify paging
      assertTrue(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
      //Send 9 more
     
      tx = tr.createTransaction();
      for (int i = 100; i < 109; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);        
         refs[i].releaseMemoryReference();
      }
      tx.commit();
     
      //verify no unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertTrue(refIds.isEmpty());
     
      //verify 109 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(109, refIds.size());
      assertSameIds(refIds, refs, 0, 108);     
     
      //Verify 100 msgs in storage
      msgIds = getMessageIds();
      assertEquals(109, msgIds.size());
      assertSameIds(msgIds, refs, 0, 108);
     
      //Verify 109 msgs in store
      assertEquals(109, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 9 refs in downcache
      assertEquals(9, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Send one more ref - should clear the down cache
     
      tx = tr.createTransaction();
      msgs[109] = CoreMessageFactory.createCoreMessage(109, true, null);
      refs[109] = ms.reference(msgs[109]);
      queue.handle(null, refs[109], tx);
      refs[109].releaseMemoryReference();
      tx.commit();
     
      //verify 10 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(10, refIds.size());
      assertSameIds(refIds, refs, 100, 109);
     
      //verify 110 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(110, refIds.size());
      assertSameIds(refIds, refs, 0, 109);
     
      //Verify 110 msgs in storage
      msgIds = getMessageIds();
      assertEquals(110, msgIds.size());
      assertSameIds(msgIds, refs, 0, 109);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
      //Send one more ref
      tx = tr.createTransaction();
      msgs[110] = CoreMessageFactory.createCoreMessage(110, true, null);
      refs[110] = ms.reference(msgs[110]);
      queue.handle(null, refs[110], tx);
      refs[110].releaseMemoryReference();
      tx.commit();
     
      //verify 10 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(10, refIds.size());
      assertSameIds(refIds, refs, 100, 109);
     
      //verify 111 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(111, refIds.size());
      assertSameIds(refIds, refs, 0, 110);
     
      //Verify 111 msgs in storage
      msgIds = getMessageIds();
      assertEquals(111, msgIds.size());
      assertSameIds(msgIds, refs, 0, 110);
     
      //Verify 101 msgs in store
      assertEquals(101, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
      //Send 9 more refs
      tx = tr.createTransaction();
      for (int i = 111; i < 120; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);        
         refs[i].releaseMemoryReference();
      }     
      tx.commit();
     
      //verify 20 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(20, refIds.size());
      assertSameIds(refIds, refs, 100, 119);
     
      //verify 120 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(120, refIds.size());
      assertSameIds(refIds, refs, 0, 119);
     
      //Verify 120 msgs in storage
      msgIds = getMessageIds();
      assertEquals(120, msgIds.size());
      assertSameIds(msgIds, refs, 0, 119);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Send 10 more refs
      tx = tr.createTransaction();
      for (int i = 120; i < 130; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);        
         refs[i].releaseMemoryReference();
     
      tx.commit();
     
      //verify 30 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(30, refIds.size());
      assertSameIds(refIds, refs, 100, 129);
     
      //verify 130 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(130, refIds.size());
      assertSameIds(refIds, refs, 0, 129);
     
      //Verify 130 msgs in storage
      msgIds = getMessageIds();
      assertEquals(130, msgIds.size());
      assertSameIds(msgIds, refs, 0, 129);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
      //Send 100 more refs then roll back
      tx = tr.createTransaction();
      for (int i = 200; i < 300; i++)
      {
         Message m = CoreMessageFactory.createCoreMessage(i, true, null);
         MessageReference ref = ms.reference(m);
         queue.handle(null, ref, tx);        
         ref.releaseMemoryReference();
     
      tx.rollback();
     
     
      //Send 10 more refs
      tx = tr.createTransaction();
      for (int i = 130; i < 140; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);
         refs[i].releaseMemoryReference();
     
      tx.commit();
     
      //verify 40 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //verify 140 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(140, refIds.size());
      assertSameIds(refIds, refs, 0, 139);
     
      //Verify 140 msgs in storage
      msgIds = getMessageIds();
      assertEquals(140, msgIds.size());
      assertSameIds(msgIds, refs, 0, 139);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging())

      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
     
      //Send one more ref
      tx = tr.createTransaction();
      msgs[140] = CoreMessageFactory.createCoreMessage(140, true, null);
      refs[140] = ms.reference(msgs[140]);
      queue.handle(null, refs[140], tx);
      refs[140].releaseMemoryReference();
      tx.commit();
     
      //verify 40 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //verify 141 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(141, refIds.size());
      assertSameIds(refIds, refs, 0, 140);
     
      //Verify 141 msgs in storage
      msgIds = getMessageIds();
      assertEquals(141, msgIds.size());
      assertSameIds(msgIds, refs, 0, 140);
     
      //Verify 101 msgs in store
      assertEquals(101, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging())
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
                           
      //Consume 1
      int consumeCount = 0;
     
      consumeInTx(queue, consumeCount, refs, 1);
      consumeCount++;

      //verify 40 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //verify 140 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(140, refIds.size());
      assertSameIds(refIds, refs, 1, 140);     
     
      //Verify 140 msgs in storage
      msgIds = getMessageIds();
      assertEquals(140, msgIds.size());
      assertSameIds(msgIds, refs, 1, 140);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 99 refs in queue
      assertEquals(99, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Now we should have 99 refs in memory, 140 refs in storage, and 1 in down cache, 99 msgs in memory
     
      //Consume 18 more
    
      consumeInTx(queue, consumeCount, refs, 18);
      consumeCount += 18;
     
     
      //verify 40 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //Verify 122 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(122, refIds.size());
      assertSameIds(refIds, refs, 19, 140);
     
      //Verify 122 msgs in storage
      msgIds = getMessageIds();
      assertEquals(122, msgIds.size());
      assertSameIds(msgIds, refs, 19, 140);
     
      //Verify 82 msgs in store
      assertEquals(82, ms.size());
     
      //Verify 81 refs in queue
      assertEquals(81, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Consume one more
     
      consumeInTx(queue, consumeCount, refs, 1);
      consumeCount++;
     
      //This should force a load of 20 and flush the downcache
     
      //verify 21 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(21, refIds.size());
      assertSameIds(refIds, refs, 120, 140);
     
      //Verify 121 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(121, refIds.size());
      assertSameIds(refIds, refs, 20, 140);
     
      //Verify 121 msgs in storage
      msgIds = getMessageIds();
      assertEquals(121, msgIds.size());
      assertSameIds(msgIds, refs, 20, 140);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Consume 20 more
     
      consumeInTx(queue, consumeCount, refs, 20);
      consumeCount += 20;
     
      //verify 1 unloaded ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(1, refIds.size());
      assertSameIds(refIds, refs, 140, 140);
     
      //Verify 120 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(101, refIds.size());
      assertSameIds(refIds, refs, 40, 140);
     
      //Verify 120 msgs in storage
      msgIds = getMessageIds();
      assertEquals(101, msgIds.size());
      assertSameIds(msgIds, refs, 40, 140);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Consume 1 more
     
      consumeInTx(queue, consumeCount, refs, 1);
      consumeCount ++;
     
      //verify 0 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 100 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(100, refIds.size());
      assertSameIds(refIds, refs, 41, 140);
     
      //Verify 100 msgs in storage
      msgIds = getMessageIds();
      assertEquals(100, msgIds.size());
      assertSameIds(msgIds, refs, 41, 140);
     
      //Verify 81 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 81 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
     
      //Consume 20 more
     
      consumeInTx(queue, consumeCount, refs, 20);
      consumeCount += 20;
     
      //verify 0 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 80 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(80, refIds.size());
      assertSameIds(refIds, refs, 61, 140);
     
      //Verify 80 msgs in storage
      msgIds = getMessageIds();
      assertEquals(80, msgIds.size());
      assertSameIds(msgIds, refs, 61, 140);
     
      //Verify 80 msgs in store
      assertEquals(80, ms.size());
     
      //Verify 80 refs in queue
      assertEquals(80, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
      //Consumer 60 more
     
           
      consumeInTx(queue, consumeCount, refs, 60);
      consumeCount += 60;
     
      //verify 0 unloaded refs in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 20 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(20, refIds.size());
      assertSameIds(refIds, refs, 121, 140);
     
      //Verify 20 msgs in storage
      msgIds = getMessageIds();
      assertEquals(20, msgIds.size());
      assertSameIds(msgIds, refs, 121, 140)
     
      //Verify 20 msgs in store
      assertEquals(20, ms.size());
     
      //Verify 20 refs in queue
      assertEquals(20, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
      //Add 20 more messages
      tx = tr.createTransaction();
      for (int i = 141; i < 161; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);
         refs[i].releaseMemoryReference();
      }
      tx.commit();
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 40 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 121, 160);
     
      //Verify 40 msgs in storage
      msgIds = getMessageIds();
      assertEquals(40, msgIds.size());
      assertSameIds(msgIds, refs, 121, 160);
     
      //Verify 40 msgs in store
      assertEquals(40, ms.size());
     
      //Verify 40 refs in queue
      assertEquals(40, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
     
      //Add 20 more messages
      tx = tr.createTransaction();
      for (int i = 161; i < 181; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);
         refs[i].releaseMemoryReference();
      }
      tx.commit();
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 60 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(60, refIds.size());
      assertSameIds(refIds, refs, 121, 180);
     
      //Verify 60 msgs in storage
      msgIds = getMessageIds();
      assertEquals(60, msgIds.size());
      assertSameIds(msgIds, refs, 121, 180);
     
      //Verify 60 msgs in store
      assertEquals(60, ms.size());
     
      //Verify 60 refs in queue
      assertEquals(60, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
      //Add 60 more messages
      tx = tr.createTransaction();
      for (int i = 181; i < 241; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], tx);
         refs[i].releaseMemoryReference();
      }
      tx.commit();
     
      //verify 20 unloaded ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(20, refIds.size());
      assertSameIds(refIds, refs, 221, 240);
     
      // Verify 120 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(120, refIds.size());
      assertSameIds(refIds, refs, 121, 240);
     
      //Verify 120 msgs in storage
      msgIds = getMessageIds();
      assertEquals(120, msgIds.size());
      assertSameIds(msgIds, refs, 121, 240);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());;
     
     
      
      //test cancellation
     
      //remove 20 but don't ack them yet
      //this should cause a load to be triggered
     
      SimpleDelivery[] dels = this.getDeliveries(queue, 20);
     
     
      //verify 0 ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      // Verify 120 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(120, refIds.size());
      assertSameIds(refIds, refs, 121, 240);
     
      //Verify 120 msgs in storage
      msgIds = getMessageIds();
      assertEquals(120, msgIds.size());
      assertSameIds(msgIds, refs, 121, 240);
 
      //Verify 120 msgs in store
      assertEquals(120, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 20 deliveries
      assertEquals(20, queue.getDeliveringCount());;
     
     
      
      //Cancel last 7
      for (int i = 19; i > 12; i--)
      {
         dels[i].cancel();  
      }
     
      // Cancel is asynch, so need to wait a bit
      Thread.sleep(250);
     
      //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
      //and the oldest refs in memory evicted off the end into the down cache
     
      //verify 0 ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      // Verify 120 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(120, refIds.size());
      assertSameIds(refIds, refs, 121, 240);
     
      //Verify 120 msgs in storage
      msgIds = getMessageIds();
      assertEquals(120, msgIds.size());
      assertSameIds(msgIds, refs, 121, 240);     
 
      //Verify 120 msgs in store
      assertEquals(120, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 13 deliveries
      assertEquals(13, queue.getDeliveringCount());;
     
     
  
      //Cancel 3 more
     
      for (int i = 12; i > 9; i--)
      {
         dels[i].cancel();
      }
     
      // Cancel is asynch, so need to wait a bit
      Thread.sleep(250);      
     
      //This should cause the down cache to be flushed
     
      //verify 10 ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(10, refIds.size());
      assertSameIds(refIds, refs, 231, 240);
     
      // Verify 120 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(120, refIds.size());
      assertSameIds(refIds, refs, 121, 240);
     
      //Verify 120 msgs in storage
      msgIds = getMessageIds();
      assertEquals(120, msgIds.size());
      assertSameIds(msgIds, refs, 121, 240);     
           
      //Verify 110 msgs in store
      assertEquals(110, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 10 deliveries
      assertEquals(10, queue.getDeliveringCount());;
     
           
     
      //Cancel the last 10
     
      for (int i = 9; i >= 0; i--)
      {
         dels[i].cancel();
      }
     
      // Cancel is asynch, so need to wait a bit
      Thread.sleep(250);      
     
      //consumeCount += 20;
     
      //This should cause the down cache to be flushed
     
      //verify 20 ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(20, refIds.size());
      assertSameIds(refIds, refs, 221, 240);
     
      // Verify 120 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(120, refIds.size());
      assertSameIds(refIds, refs, 121, 240);
     
      //Verify 120 msgs in storage
      msgIds = getMessageIds();
      assertEquals(120, msgIds.size());
      assertSameIds(msgIds, refs, 121, 240);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 0 deliveries
      assertEquals(0, queue.getDeliveringCount());;
     
     


      //Now there should be 120 message left to consume
     
      //Consume 50
     
      consumeInTx(queue, consumeCount, refs, 50);
      consumeCount += 50;
     
      //verify 0 ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());    
     
      // Verify 70 refs in storage
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(70, refIds.size());
      assertSameIds(refIds, refs, 171, 240);
     
      //Verify 70 msgs in storage
      msgIds = getMessageIds();
      assertEquals(70, msgIds.size());
      assertSameIds(msgIds, refs, 171, 240);

      //Verify 70 msgs in store
      assertEquals(70, ms.size());
     
      //Verify 70 refs in queue
      assertEquals(70, queue.memoryRefCount())
     
      //Verify not paging
      assertFalse(queue.isPaging());     
     
      //Verify 0 deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
     
      //Consume the rest
     
      consumeInTx(queue, consumeCount, refs, 70);
      consumeCount += 70;
     
      //verify 0 ref in storage
     
      refIds = getPagedReferenceIds(queue.getChannelID());
      assertEquals(0, refIds.size());    
     
      refIds = getReferenceIdsOrderedByOrd(queue.getChannelID());
      assertEquals(0, refIds.size());    
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());

      //Verify 0 msgs in store
      assertEquals(0, ms.size());
     
      //Verify 0 refs in queue
      assertEquals(0, queue.memoryRefCount());
     
      //Make sure there are no more refs in queue
     
      assertEquals(0, queue.getMessageCount());
     
     
      assertEquals(0, LockMap.instance.getSize());
        
   }
View Full Code Here

   // Public --------------------------------------------------------

   public void testPaging() throws Exception
   {
      PagingFilteredQueue p =
         new PagingFilteredQueue("queue0", 1, ms, pm, true, true,
                                 -1, null, 100, 20, 10);
          
      CoreMessage m = null;

      m = CoreMessageFactory.createCoreMessage(0);
      p.handle(null, ms.reference(m), null);

      m = CoreMessageFactory.createCoreMessage(1);
      p.handle(null, ms.reference(m), null);

   }
View Full Code Here

   }
  
  
   public void test1() throws Throwable
   {
      PagingFilteredQueue queue1 = new PagingFilteredQueue("queue1", 1, ms, pm, true, true, -1, null, 100, 20, 10);
     
      PagingFilteredQueue queue2 = new PagingFilteredQueue("queue2", 2, ms, pm, true, true, -1, null, 50, 10, 5);
    
                               
      Message[] msgs = new Message[150];
     
      MessageReference[] refs1 = new MessageReference[150];
     
      MessageReference[] refs2 = new MessageReference[150];
     
      //Send 50 refs to both channels
 
      for (int i = 0; i < 50; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      List refIds = getPagedReferenceIds(queue1.getChannelID());
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(50, refIds.size());
                                   
      assertEquals(50, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(50, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(50, ms.size());
     
      List msgIds = getMessageIds();
      assertEquals(50, msgIds.size());
     
      //Add 25 more
     
      for (int i = 50; i < 75; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      refIds = getPagedReferenceIds(queue1.getChannelID());
             
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(75, refIds.size());
                                   
      assertEquals(75, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(25, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(75, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(75, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(75, msgIds.size());
     
     
     
      // Add 25 more
     
      for (int i = 75; i < 100; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      refIds = getPagedReferenceIds(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(100, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(50, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(100, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(100, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(100, msgIds.size());
     
     
      // Add 50 more
     
      for (int i = 100; i < 150; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      refIds = getPagedReferenceIds(queue1.getChannelID());
               
      assertEquals(50, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(150, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(100, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(150, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(100, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(150, msgIds.size());
     
      //    Remove 100 then cancel
      this.cancelDeliveries(queue1, 100);
     
      this.cancelDeliveries(queue2, 100);
     
      //Now consume them all
     
      this.consume(queue1, 0, refs1, 150);
      
      this.consume(queue2, 0, refs2, 150);
     
      //    Queue1
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
                                   
      assertEquals(0, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(0, refIds.size());
                             
      assertEquals(0, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertFalse(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(0, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Should be none left
     
      assertEquals(0, queue1.getMessageCount());
     
      assertEquals(0, queue2.getMessageCount());
     
      assertEquals(0, LockMap.instance.getSize());
     
   }
View Full Code Here

      super.tearDown();
   }
  
   public void testRecoverableQueueCrash() throws Throwable
   {
      PagingFilteredQueue queue =
         new PagingFilteredQueue("queue1", 1, ms, pm, true, true,
                                 -1, null, 100, 20, 10);

      Message[] msgs = new Message[200];
     
      MessageReference[] refs = new MessageReference[200];
      
      //Send 150 np mesages
      for (int i = 0; i < 150; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs[i] = ms.reference(msgs[i]);
               
         queue.handle(null, refs[i], null);
        
         refs[i].releaseMemoryReference();
      }
     
      //Send 50 p messages
      for (int i = 150; i < 200; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs[i] = ms.reference(msgs[i]);
               
         queue.handle(null, refs[i], null);
        
         refs[i].releaseMemoryReference();
      }

      List refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(100, refIds.size());
                                               
      assertEquals(100, queue.memoryRefCount());
     
      assertEquals(0, queue.downCacheCount());
     
      assertTrue(queue.isPaging());     
     
      assertEquals(0, queue.getDeliveringCount());
     
      //Stop and restart the persistence manager
      //All the paged refs will survive
      
      pm.stop();
      tr.stop();
      ms.stop();
     
      pm =
         new JDBCPersistenceManager(sc.getDataSource(), sc.getTransactionManager(),
                  sc.getPersistenceManagerSQLProperties(),
                  true, true, true, false, 100);     
      pm.start();
     
      ms = new SimpleMessageStore();
      ms.start();
     
      tr = new TransactionRepository(pm, ms, idm);

      tr.start();
        
      PagingFilteredQueue queue2 =
         new PagingFilteredQueue("queue1", 1, ms, pm, true, true,
                                 -1, null, 100, 20, 10);
      queue2.deactivate();
      queue2.load();
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(50, refIds.size());
     
      assertEquals(100, queue2.memoryRefCount());
      assertEquals(0, queue2.downCacheCount());
      assertFalse(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
                  
      this.consume(queue2, 100, refs, 100);
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(0, refIds.size());
                                               
      assertEquals(0, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertFalse(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
     
      assertEquals(0, queue2.getMessageCount());
     
      assertEquals(0, LockMap.instance.getSize());
   }
View Full Code Here

  
   public void testNonRecoverableQueueCrash() throws Throwable
   {
      //Non recoverable queue - eg temporary queue
     
      PagingFilteredQueue queue =
         new PagingFilteredQueue("queue1", 1, ms, pm, true, true,
                                 -1, null, 100, 20, 10);
     
      Message[] msgs = new Message[200];
     
      MessageReference[] refs = new MessageReference[200];
      
      //Send 150 np mesages
      for (int i = 0; i < 150; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs[i] = ms.reference(msgs[i]);
               
         queue.handle(null, refs[i], null);
        
         refs[i].releaseMemoryReference();
      }
     
      //Send 50 p messages
      for (int i = 150; i < 200; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs[i] = ms.reference(msgs[i]);
               
         queue.handle(null, refs[i], null);
        
         refs[i].releaseMemoryReference();
      }

      List refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(100, refIds.size());
                                               
      assertEquals(100, queue.memoryRefCount());
     
      assertEquals(0, queue.downCacheCount());
     
      assertTrue(queue.isPaging());     
     
      assertEquals(0, queue.getDeliveringCount());
     
      //Stop and restart the persistence manager
      //Only the paged messages will survive
      //This is what would happen if the server crashed

      pm.stop();
      tr.stop();
      ms.stop();
     
      pm =
         new JDBCPersistenceManager(sc.getDataSource(), sc.getTransactionManager(),
                  sc.getPersistenceManagerSQLProperties(),
                  true, true, true, false, 100);    
      pm.start();
     
      ms = new SimpleMessageStore();
      ms.start();
     
      tr = new TransactionRepository(pm, ms, idm);
      tr.start();

      PagingFilteredQueue queue2 =
         new PagingFilteredQueue("queue1", 1, ms, pm, true, true,
                                 -1, null, 100, 20, 10);
      queue2.deactivate();
      queue2.load();
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(50, refIds.size());
     
      List msgIds = getMessageIds();
      assertEquals(50, msgIds.size());
                                                                 
      assertEquals(100, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertFalse(queue2.isPaging());     
     
      this.consume(queue2, 100, refs, 100);
     
      assertEquals(0, queue2.getDeliveringCount());
     
      assertEquals(0, queue2.getMessageCount());
     
      assertEquals(0, LockMap.instance.getSize());
   }
View Full Code Here

  
   public void testNonRecoverableQueueRemoveAllReferences() throws Throwable
   {
      //Non recoverable queue - eg temporary queue
     
      PagingFilteredQueue queue =
         new PagingFilteredQueue("queue1", 1, ms, pm, true, true,
                                 -1, null, 100, 20, 10);
 
      Message[] msgs = new Message[200];
     
      MessageReference[] refs = new MessageReference[200];
      
      //Send 150 np mesages
      for (int i = 0; i < 150; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs[i] = ms.reference(msgs[i]);
               
         queue.handle(null, refs[i], null);
        
         refs[i].releaseMemoryReference();
      }
     
      //Send 50 p messages
      for (int i = 150; i < 200; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs[i] = ms.reference(msgs[i]);
               
         queue.handle(null, refs[i], null);
        
         refs[i].releaseMemoryReference();
      }

      List refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(100, refIds.size());
                                               
      assertEquals(100, queue.memoryRefCount());
     
      assertEquals(0, queue.downCacheCount());
     
      assertTrue(queue.isPaging());     
     
      assertEquals(0, queue.getDeliveringCount());
     
      queue.removeAllReferences();
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      List msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
                                                                 
      assertEquals(0, queue.memoryRefCount());
     
      assertEquals(0, queue.downCacheCount());
     
      assertFalse(queue.isPaging());     
     
      assertEquals(0, queue.getDeliveringCount());
     
      assertEquals(0, queue.getMessageCount());
     
      assertEquals(0, LockMap.instance.getSize());
   }
View Full Code Here

      super.setUp();
   }
  
   public void test1() throws Throwable
   {
      PagingFilteredQueue queue1 = new PagingFilteredQueue("queue1", 1, ms, pm, true, true, -1, null, 100, 20, 10);
     
      PagingFilteredQueue queue2 = new PagingFilteredQueue("queue2", 2, ms, pm, true, true, -1, null, 50, 10, 5);
    
                           
      Message[] msgs = new Message[150];
     
      MessageReference[] refs1 = new MessageReference[150];
     
      MessageReference[] refs2 = new MessageReference[150];
     
      //Send 50 refs to both channels
      Transaction tx = this.createXATx();
      for (int i = 0; i < 50; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
        
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
     
      //Queue1
      List refIds = getPagedReferenceIds(queue1.getChannelID());
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(50, refIds.size());
                                   
      assertEquals(50, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(50, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(50, ms.size());
     
      List msgIds = getMessageIds();
      assertEquals(50, msgIds.size());
     
      //Add 25 more
      tx = createXATx();
      for (int i = 50; i < 75; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
        
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
     
      //Queue1
      refIds = getPagedReferenceIds(queue1.getChannelID());
             
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(75, refIds.size());
                                   
      assertEquals(75, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(25, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(75, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(75, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(75, msgIds.size());
     
     
     
      // Add 25 more
      tx = createXATx();
      for (int i = 75; i < 100; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
        
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
     
      //Queue1
      refIds = getPagedReferenceIds(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(100, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(50, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(100, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(100, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(100, msgIds.size());
     
     
      // Add 50 more
      tx = createXATx();
      for (int i = 100; i < 150; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], tx);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], tx);
        
         refs2[i].releaseMemoryReference();
      }
      tx.prepare();
      tx.commit();
     
      //Queue1
      refIds = getPagedReferenceIds(queue1.getChannelID());
               
      assertEquals(50, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
      assertEquals(150, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getPagedReferenceIds(queue2.getChannelID());
      assertEquals(100, refIds.size());
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(150, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(100, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(150, msgIds.size());
     
      //    Remove 100 then cancel
      this.cancelDeliveries(queue1, 100);
     
      this.cancelDeliveries(queue2, 100);
     
      //Now consume them all
     
      this.consumeIn2PCTx(queue1, 0, refs1, 150);
      
      this.consumeIn2PCTx(queue2, 0, refs2, 150);
     
      //    Queue1
      refIds = getReferenceIdsOrderedByOrd(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
                                   
      assertEquals(0, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByOrd(queue2.getChannelID());
      assertEquals(0, refIds.size());
                             
      assertEquals(0, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertFalse(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(0, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Should be none left
     
      assertEquals(0, queue1.getMessageCount());
     
      assertEquals(0, queue2.getMessageCount());
     
      assertEquals(0, LockMap.instance.getSize());
     
   }
View Full Code Here

      super.tearDown();
   }
  
   public void test1() throws Throwable
   {
      PagingFilteredQueue queue = new PagingFilteredQueue("queue1", 1, ms, pm, true, true, -1, null, 100, 20, 10);
     
      Message[] msgs = new Message[241];
     
      MessageReference[] refs = new MessageReference[241];
 
      //Send 99
     
      for (int i = 0; i < 99; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);
         refs[i].releaseMemoryReference();
      }
     
      //verify no refs in storage
           
      List refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertTrue(refIds.isEmpty());
     
      //Verify no msgs in storage
      List msgIds = getMessageIds();
      assertTrue(msgIds.isEmpty());
     
      //Verify 99 msgs in store
      assertEquals(99, ms.size());
     
      //Verify 99 refs in queue
      assertEquals(99, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
      //Send one more ref
     
      msgs[99] = CoreMessageFactory.createCoreMessage(99, false, null);
      refs[99] = ms.reference(msgs[99]);
      queue.handle(null, refs[99], null);
      refs[99].releaseMemoryReference();
     
      //verify no refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertTrue(refIds.isEmpty());
     
      //Verify no msgs in storage
      msgIds = getMessageIds();
      assertTrue(msgIds.isEmpty());
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
           
      //Verify paging
      assertTrue(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
                 
      //Send 9 more
     
      for (int i = 100; i < 109; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);
         refs[i].releaseMemoryReference();
      }
     
      //verify no refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertTrue(refIds.isEmpty());
     
      //Verify no msgs in storage
      msgIds = getMessageIds();
      assertTrue(msgIds.isEmpty());
     
      //Verify 100 msgs in store
      assertEquals(109, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 9 refs in downcache
      assertEquals(9, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Send one more ref - should clear the down cache
     
      msgs[109] = CoreMessageFactory.createCoreMessage(109, false, null);
      refs[109] = ms.reference(msgs[109]);
      queue.handle(null, refs[109], null);
      refs[109].releaseMemoryReference();
     
      //verify 10 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(10, refIds.size());
      assertSameIds(refIds, refs, 100, 109);
     
      //Verify 10 msgs in storage
      msgIds = getMessageIds();
      assertEquals(10, msgIds.size());
      assertSameIds(msgIds, refs, 100, 109);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
      //Send one more ref
     
      msgs[110] = CoreMessageFactory.createCoreMessage(110, false, null);
      refs[110] = ms.reference(msgs[110]);
      queue.handle(null, refs[110], null);
      refs[110].releaseMemoryReference();
     
      //verify 10 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(10, refIds.size());
      assertSameIds(refIds, refs, 100, 109);
     
      //Verify 10 msgs in storage
      msgIds = getMessageIds();
      assertEquals(10, msgIds.size());
      assertSameIds(msgIds, refs, 100, 109);
     
      //Verify 101 msgs in store
      assertEquals(101, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
      //Send 9 more refs
     
      for (int i = 111; i < 120; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);        
         refs[i].releaseMemoryReference();
      }     
     
      //verify 20 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(20, refIds.size());
      assertSameIds(refIds, refs, 100, 119);
     
      //Verify 20 msgs in storage
      msgIds = getMessageIds();
      assertEquals(20, msgIds.size());
      assertSameIds(msgIds, refs, 100, 119);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Send 10 more refs
     
      for (int i = 120; i < 130; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);        
         refs[i].releaseMemoryReference();
     
     
      //verify 30 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(30, refIds.size());
      assertSameIds(refIds, refs, 100, 129);
     
      //Verify 30 msgs in storage
      msgIds = getMessageIds();
      assertEquals(30, msgIds.size());
      assertSameIds(msgIds, refs, 100, 129);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Send 10 more refs
     
      for (int i = 130; i < 140; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);        
         refs[i].releaseMemoryReference();
     
     
      //verify 40 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //Verify 40 msgs in storage
      msgIds = getMessageIds();
      assertEquals(40, msgIds.size());
      assertSameIds(msgIds, refs, 100, 139);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging())

      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
     
      //Send one more ref
     
      msgs[140] = CoreMessageFactory.createCoreMessage(140, false, null);
      refs[140] = ms.reference(msgs[140]);
      queue.handle(null, refs[140], null);
      refs[140].releaseMemoryReference();
     
      //verify 40 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //Verify 40 msgs in storage
      msgIds = getMessageIds();
      assertEquals(40, msgIds.size());
      assertSameIds(msgIds, refs, 100, 139);
     
      //Verify 100 msgs in store
      assertEquals(101, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging())
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
               
     
     
      //Consume 1
      int consumeCount = 0;
      consume(queue, consumeCount, refs, 1);
      consumeCount++;
     
      //verify 40 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //Verify 40 msgs in storage
      msgIds = getMessageIds();
      assertEquals(40, msgIds.size());
      assertSameIds(msgIds, refs, 100, 139);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 99 refs in queue
      assertEquals(99, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Now we should have 99 refs in memory, 40 refs in storage, and 1 in down cache, 100 msgs in memory
     
      //Consume 18 more
      consume(queue, consumeCount, refs, 18);
      consumeCount += 18;
     
      //We should have 81 refs in memory, 40 refs in storage, and 1 in down cache, 82 msgs in memory
     
      //verify 40 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(40, refIds.size());
      assertSameIds(refIds, refs, 100, 139);
     
      //Verify 40 msgs in storage
      msgIds = getMessageIds();
      assertEquals(40, msgIds.size());
      assertSameIds(msgIds, refs, 100, 139);
     
      //Verify 82 msgs in store
      assertEquals(82, ms.size());
     
      //Verify 81 refs in queue
      assertEquals(81, queue.memoryRefCount());
     
      //Verify 1 refs in downcache
      assertEquals(1, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Consume one more
     
      consume(queue, consumeCount, refs, 1);
      consumeCount++;
     
      //This should force a load of 20 and flush the downcache
     
      //verify 21 refs in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
     
      assertEquals(21, refIds.size());
      assertSameIds(refIds, refs, 120, 140);
     
      //Verify 21 msgs in storage
      msgIds = getMessageIds();
      assertEquals(21, msgIds.size());
      assertSameIds(msgIds, refs, 120, 140);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Consume 20 more
     
      consume(queue, consumeCount, refs, 20);
      consumeCount += 20;
     
      //verify 1 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(1, refIds.size());
      assertSameIds(refIds, refs, 140, 140);
     
      //Verify 1 msgs in storage
      msgIds = getMessageIds();
      assertEquals(1, msgIds.size());
      assertSameIds(msgIds, refs, 140, 140);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
     
      //Consume 1 more
     
      consume(queue, consumeCount, refs, 1);
      consumeCount ++;
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Verify 81 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 81 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
     
      //Consume 20 more
     
      consume(queue, consumeCount, refs, 20);
      consumeCount += 20;
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Verify 80 msgs in store
      assertEquals(80, ms.size());
     
      //Verify 80 refs in queue
      assertEquals(80, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
      //Consumer 60 more
     
           
      consume(queue, consumeCount, refs, 60);
      consumeCount += 60;
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Verify 20 msgs in store
      assertEquals(20, ms.size());
     
      //Verify 20 refs in queue
      assertEquals(20, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
           
     
     
      //Add 20 more messages
      for (int i = 141; i < 161; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);
         refs[i].releaseMemoryReference();
      }
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Verify 40 msgs in store
      assertEquals(40, ms.size());
     
      //Verify 40 refs in queue
      assertEquals(40, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
     
      //Add 20 more messages
      for (int i = 161; i < 181; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);
         refs[i].releaseMemoryReference();
      }
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Verify 60 msgs in store
      assertEquals(60, ms.size());
     
      //Verify 60 refs in queue
      assertEquals(60, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify not paging
      assertFalse(queue.isPaging());
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());
     
     
     
      //Add 60 more messages
      for (int i = 181; i < 241; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
         refs[i] = ms.reference(msgs[i]);
         queue.handle(null, refs[i], null);
         refs[i].releaseMemoryReference();
      }
     
      //verify 20 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(20, refIds.size());
      assertSameIds(refIds, refs, 221, 240);
     
      //Verify 20 msgs in storage
      msgIds = getMessageIds();
      assertEquals(20, msgIds.size());
      assertSameIds(msgIds, refs, 221, 240);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify 0 refs in downcache
      assertEquals(0, queue.downCacheCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify no deliveries
      assertEquals(0, queue.getDeliveringCount());;
     
     
      
      //test cancellation
     
      //remove 20 but don't ack them yet
      //this should cause a load to be triggered
     
//      CancellingReceiver r = new CancellingReceiver(20);
//      queue.add(r);
      SimpleDelivery[] dels = getDeliveries(queue, 20);
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
 
      //Verify 120 msgs in store
      assertEquals(120, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 20 deliveries
      assertEquals(20, queue.getDeliveringCount());;
     
     
      
      //Cancel last 7
      for (int i = 19; i > 12; i--)
      {
         dels[i].cancel()
      }
     
      // Cancel is asynch, so need to wait a bit
      Thread.sleep(250);      
     
      //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
      //and the oldest refs in memory evicted off the end into the down cache
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
 
      //Verify 120 msgs in store
      assertEquals(120, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 13 deliveries
      assertEquals(13, queue.getDeliveringCount());;
     
     
  
      //Cancel 3 more
     
      for (int i = 12; i > 9; i--)
      {
         dels[i].cancel();
      }
     
      // Cancel is asynch, so need to wait a bit
      Thread.sleep(250);      
     
      //This should cause the down cache to be flushed
     
      //verify 10 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(10, refIds.size());
      assertSameIds(refIds, refs, 231, 240);
     
      //Verify 10 msgs in storage
      msgIds = getMessageIds();
      assertEquals(10, msgIds.size());
      assertSameIds(msgIds, refs, 231, 240);
     
      //Verify 110 msgs in store
      assertEquals(110, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 10 deliveries
      assertEquals(10, queue.getDeliveringCount());;
     
           
     
      //Cancel the last 10
     
      for (int i = 9; i >= 0; i--)
      {
         dels[i].cancel();
      }
      // Cancel is asynch, so need to wait a bit
      Thread.sleep(250);      
     
      //consumeCount += 20;
     
      //This should cause the down cache to be flushed
     
      //verify 20 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(20, refIds.size());
      assertSameIds(refIds, refs, 221, 240);
     
      //Verify 20 msgs in storage
      msgIds = getMessageIds();
      assertEquals(20, msgIds.size());
      assertSameIds(msgIds, refs, 221, 240);
     
      //Verify 100 msgs in store
      assertEquals(100, ms.size());
     
      //Verify 100 refs in queue
      assertEquals(100, queue.memoryRefCount());
     
      //Verify paging
      assertTrue(queue.isPaging());     
     
      //Verify 0 deliveries
      assertEquals(0, queue.getDeliveringCount());;
     
      assertEquals(0, queue.downCacheCount());


      //Now there should be 120 message left to consume
     
      //Consume 50
     
      consume(queue, consumeCount, refs, 50);
      consumeCount += 50;
           

      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());    
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());

      //Verify 70 msgs in store
      assertEquals(70, ms.size());
     
      //Verify 0 deliveries
      assertEquals(0, queue.getDeliveringCount());
     
      assertEquals(0, queue.downCacheCount());
                 
      //Verify 70 refs in queue
      assertEquals(70, queue.memoryRefCount())
     
//    Verify not paging
      assertFalse(queue.isPaging());     
     
     
     
     
     
     
      //Consume the rest
     
      consume(queue, consumeCount, refs, 70);
      consumeCount += 70;
     
      //verify 0 ref in storage
     
      refIds = getReferenceIdsOrderedByPageOrd(queue.getChannelID());
      assertEquals(0, refIds.size());    
     
      //Verify 0 msgs in storage
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());

      //Verify 0 msgs in store
      assertEquals(0, ms.size());
     
      //Verify 0 refs in queue
      assertEquals(0, queue.memoryRefCount());
     
      //Make sure there are no more refs in queue
     
      assertEquals(0, queue.getMessageCount());
           
      assertEquals(0, LockMap.instance.getSize());
   }
View Full Code Here

      super.tearDown();
   }
  
   public void test1() throws Throwable
   {
      PagingFilteredQueue queue1 = new PagingFilteredQueue("queue1", 1, ms, pm, true, true, -1, null, 100, 20, 10);
    
      PagingFilteredQueue queue2 = new PagingFilteredQueue("queue2", 2, ms, pm, true, true, -1, null, 50, 10, 5);
          
      Message[] msgs = new Message[150];
     
      MessageReference[] refs1 = new MessageReference[150];
     
      MessageReference[] refs2 = new MessageReference[150];
     
      //Send 50 refs to both channels
 
      for (int i = 0; i < 50; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      List refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
      assertEquals(0, refIds.size());
                                   
      assertEquals(50, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(0, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(50, ms.size());
     
      List msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Add 25 more
     
      for (int i = 50; i < 75; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
             
      assertEquals(0, refIds.size());
                                   
      assertEquals(75, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(25, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(75, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(25, msgIds.size());
     
     
     
      // Add 25 more
     
      for (int i = 75; i < 100; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(50, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(100, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(50, msgIds.size());
     
     
      // Add 50 more
     
      for (int i = 100; i < 150; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, false, null);
        
         refs1[i] = ms.reference(msgs[i]);
               
         queue1.handle(null, refs1[i], null);
        
         refs1[i].releaseMemoryReference();
        
         refs2[i] = ms.reference(msgs[i]);
        
         queue2.handle(null, refs2[i], null);
        
         refs2[i].releaseMemoryReference();
      }
     
      //Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
               
      assertEquals(50, refIds.size());
                                   
      assertEquals(100, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertTrue(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(100, refIds.size());
                             
      assertEquals(50, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertTrue(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(100, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(100, msgIds.size());
     
      //Remove 100 then cancel
      this.cancelDeliveries(queue1, 100);
     
      this.cancelDeliveries(queue2, 100);
     
      //Now consume them all
     
      this.consume(queue1, 0, refs1, 150);
      
      this.consume(queue2, 0, refs2, 150);
     
      //    Queue1
      refIds = getReferenceIdsOrderedByPageOrd(queue1.getChannelID());
               
      assertEquals(0, refIds.size());
                                   
      assertEquals(0, queue1.memoryRefCount());
     
      assertEquals(0, queue1.downCacheCount());
     
      assertFalse(queue1.isPaging());     
     
      assertEquals(0, queue1.getDeliveringCount());
     
      //Queue2
     
      refIds = getReferenceIdsOrderedByPageOrd(queue2.getChannelID());
      assertEquals(0, refIds.size());
                             
      assertEquals(0, queue2.memoryRefCount());
     
      assertEquals(0, queue2.downCacheCount());
     
      assertFalse(queue2.isPaging());     
     
      assertEquals(0, queue2.getDeliveringCount());
           
      //Msgs
     
      assertEquals(0, ms.size());
     
      msgIds = getMessageIds();
      assertEquals(0, msgIds.size());
     
      //Should be none left
     
      assertEquals(0, queue1.getMessageCount());
     
      assertEquals(0, queue2.getMessageCount());
     
      assertEquals(0, LockMap.instance.getSize());
     
   }
View Full Code Here

TOP

Related Classes of org.jboss.messaging.core.local.PagingFilteredQueue

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.