Examples of org.jboss.messaging.core.impl.MessagingQueue$ClearRecoveryMapTimeoutTarget

org.jboss.messaging.core.impl.MessagingQueue
A MessagingQueue Can be used to implement a point to point queue, or a subscription fed from a topic @author Ovidiu Feodorov @author Tim Fox @version $Revision: 1295 $ $Id: Queue.java 1295 2006-09-15 17:44:02Z timfox $

   
   public void testNonRecoverableQueueRemoveAllReferences() throws Throwable
   {
      //Non recoverable queue - eg temporary queue
      
      MessagingQueue queue = new MessagingQueue(1, "queue1", 1, ms, pm, false, -1, null, 100, 20, 10, false, 300000);
      queue.activate();
        
      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] = msgs[i].createReference();
                
         queue.handle(null, refs[i], null); 
      }
      
      //Send 50 p messages
      for (int i = 150; i < 200; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         
         refs[i] = msgs[i].createReference();
                
         queue.handle(null, refs[i], null); 
      }


      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());
   }

View Full Code Here

      testRecoverableQueueRestartWithDownCache(130);
   }
   
   private void testRecoverableQueueRestartWithDownCache(int num) throws Throwable
   {
      MessagingQueue queue =
         new MessagingQueue(1, "queue1", 1, ms, pm, true, -1, null, 100, 20, 20, false, 300000);
      queue.activate();
      
      Message[] msgs = new Message[num];
      
      MessageReference[] refs = new MessageReference[num];
            
      for (int i = 0; i < num; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         
         refs[i] = msgs[i].createReference();
                
         queue.handle(null, refs[i], null); 
      }
      
            
      pm.stop();
      tr.stop();
      ms.stop();
      
      pm =
         new JDBCPersistenceManager(sc.getDataSource(), sc.getTransactionManager(),
                  sc.getPersistenceManagerSQLProperties(),
                  true, true, true, false, 100, !sc.getDatabaseName().equals("oracle"));   
      ((JDBCPersistenceManager)pm).injectNodeID(1);
      pm.start();
      
      ms = new SimpleMessageStore();
      ms.start();
      
      tr = new TransactionRepository(pm, ms, idm);


      tr.start();
         
      MessagingQueue queue2 =
         new MessagingQueue(1, "queue1", 1, ms, pm, true, -1, null, 100, 20, 20, false, 300000);
    
      queue2.load();
      queue2.activate();
                              
      this.consume(queue2, 0, refs, num);            
   }

View Full Code Here

      super.tearDown();
   }
   
   public void test1() throws Throwable
   {
      MessagingQueue queue = new MessagingQueue(1, "queue1", 1, ms, pm, true, -1, null, 100, 20, 10, false, 300000);
      queue.activate();
      
      Message[] msgs = new Message[241];
      
      MessageReference[] refs = new MessageReference[241];
  
      //Send 99
      
      for (int i = 0; i < 99; i++)
      {
         msgs[i] = CoreMessageFactory.createCoreMessage(i, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);
      }
      
      //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 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, true, null);
      refs[99] = ms.reference(msgs[99]);
      queue.handle(null, refs[99], null);


      //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 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, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);         
      }
      
      //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 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, true, null);
      refs[109] = ms.reference(msgs[109]);
      queue.handle(null, refs[109], null);           
      //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 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, true, null);
      refs[110] = ms.reference(msgs[110]);
      queue.handle(null, refs[110], null);
 
      //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 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, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);        
      }      
      
      //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 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, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);         
      }  
      
      //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 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, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);         


      }  
      
      //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 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, true, null);
      refs[140] = ms.reference(msgs[140]);
      queue.handle(null, refs[140], null);


      //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 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 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 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
      consume(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 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 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 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 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 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 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 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 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 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 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 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, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);
      }
      
      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 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, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);
      }
      
      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 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, true, null);
         refs[i] = msgs[i].createReference();
         queue.handle(null, refs[i], null);
      }
      
      //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 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 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();
      }


      //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 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();
      }


      //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 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();
      }
           
      //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 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
      
      consume(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 refs in queue
      assertEquals(70, queue.memoryRefCount());  
      
      //Verify not paging
      assertFalse(queue.isPaging());      
      
      //Verify 0 deliveries
      assertEquals(0, queue.getDeliveringCount());
      
      
      
      
      //Consume the rest
      
      consume(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 refs in queue
      assertEquals(0, queue.memoryRefCount());
      
      //Make sure there are no more refs in queue
      
      assertEquals(0, queue.getMessageCount());
   }

View Full Code Here

         if (mapping.getFilterString() != null)
         {
           filter = filterFactory.createFilter(mapping.getFilterString());
         }
         
         Queue queue = new MessagingQueue(mapping.getNodeId(), mapping.getQueueName(), mapping.getChannelId(),
                                          mapping.isRecoverable(), filter, true);
         
         Condition condition = conditionFactory.createCondition(mapping.getConditionText());
         
         addBindingInMemory(new Binding(condition, queue, false));
         
         if (mapping.isAllNodes())
         {
           // insert into db if not already there
           if (!loadedBindings.containsKey(queue.getName()))
           {
             //Create a local binding too
             
            long channelID = channelIDManager.getID();
                        
            Queue queue2 = new MessagingQueue(thisNodeID, mapping.getQueueName(), channelID, ms, pm,
                                             mapping.isRecoverable(), mapping.getMaxSize(), filter,
                                             mapping.getFullSize(), mapping.getPageSize(), mapping.getDownCacheSize(),
                                             true, mapping.getRecoverDeliveriesTimeout());     
            
            Binding localBinding = new Binding(condition, queue2, true);

View Full Code Here

      if (mapping.getFilterString() != null)
      {
        filter = filterFactory.createFilter(mapping.getFilterString());
      }
      
      Queue queue = new MessagingQueue(mapping.getNodeId(), mapping.getQueueName(), mapping.getChannelId(),
                                       mapping.isRecoverable(), filter, mapping.isClustered());
      
      Condition condition = conditionFactory.createCondition(mapping.getConditionText());
      
      //addBindingInMemory(new Binding(condition, queue, mapping.isAllNodes()));
      addBindingInMemory(new Binding(condition, queue, false));
      
      if (allNodes)
     {
       if (trace) { log.trace("allNodes is true, so also forcing a local bind"); }
       
       //There is the possibility that two nodes send a bind all with the same name simultaneously OR
       //a node starts and sends a bind "ALL" and the other nodes already have a queue with that name
       //This is ok - but we must check for this and not create the local binding in this case
                             
       //Bind locally


       long channelID = channelIDManager.getID();
       
       Queue queue2 = new MessagingQueue(thisNodeID, mapping.getQueueName(), channelID, ms, pm,
                                        mapping.isRecoverable(), mapping.getMaxSize(), filter,
                                        mapping.getFullSize(), mapping.getPageSize(), mapping.getDownCacheSize(), true,
                                        mapping.getRecoverDeliveriesTimeout());


       //We must cast back asynchronously to avoid deadlock
       boolean added = internalAddBinding(new Binding(condition, queue2, true), false, false);
       
       if (added)
       {         
         if (trace) { log.trace(this + " inserted in binding locally"); }      
         
         queue2.load();
           
          queue2.activate();         
       }
     }
      
      synchronized (waitForBindUnbindLock)
      {

View Full Code Here

                  if (selector != null)
                  {
                     filter = filterFactory.createFilter(selector);
                  }


                  Queue queue = new MessagingQueue(thisNodeID, queueName, channelID, ms, pm,
                                                   true, filter, bindingClustered && clustered);


                  if (trace) { log.trace(this + " loaded binding from storage: " + queueName); }


                  Condition condition = conditionFactory.createCondition(conditionText);

View Full Code Here

                  if (selector != null)
                  {
                     filter = filterFactory.createFilter(selector);
                  }


                  Queue queue = new MessagingQueue(thisNodeID, queueName, channelID, ms, pm,
                                                   true, filter, bindingClustered && clustered);


                  if (trace) { log.trace(this + " loaded binding from storage: " + queueName); }


                  Condition condition = conditionFactory.createCondition(conditionText);

View Full Code Here


         dm.registerDestination(mDest);


         if (dest.isQueue())
         {
            Queue coreQueue = new MessagingQueue(nodeId, dest.getName(),
                                     idm.getID(), ms, pm, false, -1, null,
                                       fullSize, pageSize, downCacheSize, postOffice.isClustered(),
                                       sp.getRecoverDeliveriesTimeout());




            Condition cond = new JMSCondition(true, dest.getName());


           // make a binding for this temporary queue


            // temporary queues need to bound on ALL nodes of the cluster
            postOffice.addBinding(new Binding(cond, coreQueue, true), postOffice.isClustered());


            coreQueue.activate();
         }
      }
      catch (Throwable t)
      {
         throw ExceptionUtil.handleJMSInvocation(t, this + " addTemporaryDestination");

View Full Code Here

            // non-durable subscription
            if (log.isTraceEnabled()) { log.trace(this + " creating new non-durable subscription on " + jmsDestination); }


            // Create the non durable sub


            queue = new MessagingQueue(nodeId, GUIDGenerator.generateGUID(),
                                idm.getID(), ms, pm, false,
                                mDest.getMaxSize(), selector,
                                mDest.getFullSize(),
                                mDest.getPageSize(),
                                mDest.getDownCacheSize(),
                                mDest.isClustered(),
                                sp.getRecoverDeliveriesTimeout());


            JMSCondition topicCond = new JMSCondition(false, jmsDestination.getName());


            postOffice.addBinding(new Binding(topicCond, queue, false), false);


            queue.activate();


            String counterName = TopicService.SUBSCRIPTION_MESSAGECOUNTER_PREFIX + queue.getName();


            int dayLimitToUse = mDest.getMessageCounterHistoryDayLimit();
            if (dayLimitToUse == -1)
            {
               //Use override on server peer
               dayLimitToUse = sp.getDefaultMessageCounterHistoryDayLimit();
            }


            //We don't create message counters on temp topics
            if (!mDest.isTemporary())
            {
              MessageCounter counter =  new MessageCounter(counterName, null, queue, true, false, dayLimitToUse);


              sp.getMessageCounterManager().registerMessageCounter(counterName, counter);
            }
         }
         else
         {
            if (jmsDestination.isTemporary())
            {
               throw new InvalidDestinationException("Cannot create a durable subscription on a temporary topic");
            }


            // We have a durable subscription, look it up
            String clientID = connectionEndpoint.getClientID();
            if (clientID == null)
            {
               throw new JMSException("Cannot create durable subscriber without a valid client ID");
            }


            // See if there any bindings with the same client_id.subscription_name name


            String name = MessageQueueNameHelper.createSubscriptionName(clientID, subscriptionName);


            Binding binding = postOffice.getBindingForQueueName(name);


            if (binding == null)
            {
               // Does not already exist


               if (trace) { log.trace(this + " creating new durable subscription on " + jmsDestination); }


               queue = new MessagingQueue(nodeId, name, idm.getID(),
                                          ms, pm, true,
                                          mDest.getMaxSize(), selector,
                                          mDest.getFullSize(),
                                          mDest.getPageSize(),
                                          mDest.getDownCacheSize(),
                                          mDest.isClustered(),
                                          sp.getRecoverDeliveriesTimeout());


               // Durable subs must be bound on ALL nodes of the cluster (if clustered)


               postOffice.addBinding(new Binding(new JMSCondition(false, jmsDestination.getName()), queue, true),
                                     postOffice.isClustered() && mDest.isClustered());


               queue.activate();


               //We don't create message counters on temp topics
               if (!mDest.isTemporary())
               {
                 String counterName = TopicService.SUBSCRIPTION_MESSAGECOUNTER_PREFIX + queue.getName();


                 MessageCounter counter =
                    new MessageCounter(counterName, subscriptionName, queue, true, true,
                                       mDest.getMessageCounterHistoryDayLimit());


                 sp.getMessageCounterManager().registerMessageCounter(counterName, counter);
               }
            }
            else
            {
               //Durable sub already exists


              queue = binding.queue;


               if (trace) { log.trace(this + " subscription " + subscriptionName + " already exists"); }


              //Check if it is already has a subscriber
              //We can't have more than one subscriber at a time on the durable sub unless it is clustered
               //we need this for clustered since otherwise we wouldn't be able to fail over subcribers for the same durable
               //sub onto a node which already has one


               if (queue.getLocalDistributor().getNumberOfReceivers() > 0 && !mDest.isClustered())
               {
                 throw new IllegalStateException("Cannot create a subscriber on the durable subscription since it already has subscriber(s)");
               }


               // If the durable sub exists because it is clustered and was created on this node due to a bind on another node
               // then it will have no message counter


               String counterName = TopicService.SUBSCRIPTION_MESSAGECOUNTER_PREFIX + queue.getName();


               boolean createCounter = false;


               if (sp.getMessageCounterManager().getMessageCounter(counterName) == null)
               {
                 createCounter = true;
               }


               // From javax.jms.Session Javadoc (and also JMS 1.1 6.11.1):
               // A client can change an existing durable subscription by creating a durable
               // TopicSubscriber with the same name and a new topic and/or message selector.
               // Changing a durable subscriber is equivalent to unsubscribing (deleting) the old
               // one and creating a new one.


               String filterString = queue.getFilter() != null ? queue.getFilter().getFilterString() : null;


               boolean selectorChanged =
                  (selectorString == null && filterString != null) ||
                  (filterString == null && selectorString != null) ||
                  (filterString != null && selectorString != null &&
                           !filterString.equals(selectorString));


               if (trace) { log.trace("selector " + (selectorChanged ? "has" : "has NOT") + " changed"); }


               String oldTopicName = ((JMSCondition)binding.condition).getName();


               boolean topicChanged = !oldTopicName.equals(jmsDestination.getName());


               if (log.isTraceEnabled()) { log.trace("topic " + (topicChanged ? "has" : "has NOT") + " changed"); }


               if (selectorChanged || topicChanged)
               {
                  if (trace) { log.trace("topic or selector changed so deleting old subscription"); }


                  // Unbind the durable subscription


                  // Durable subs must be unbound on ALL nodes of the cluster


                  postOffice.removeBinding(queue.getName(), postOffice.isClustered() && mDest.isClustered());


                  // create a fresh new subscription


                  queue = new MessagingQueue(nodeId, name, idm.getID(), ms, pm, true,
                                        mDest.getMaxSize(), selector,
                                        mDest.getFullSize(),
                                        mDest.getPageSize(),
                                        mDest.getDownCacheSize(),
                                        mDest.isClustered(),

View Full Code Here

         {           
            // Create a new queue


            JMSCondition queueCond = new JMSCondition(true, destination.getName());
            
            queue = new MessagingQueue(nodeId, destination.getName(),
                                     serverPeer.getChannelIDManager().getID(),
                                       serverPeer.getMessageStore(), serverPeer.getPersistenceManagerInstance(),
                                       true,
                                       destination.getMaxSize(), null,
                                       destination.getFullSize(), destination.getPageSize(),

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.jboss.messaging.core.impl.MessagingQueue$ClearRecoveryMapTimeoutTarget

EDU.oswego.cs.dl.util.concurrent.ConcurrentHashMap

EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap

org.jboss.jms.server.destination.QueueService

org.jboss.jms.server.endpoint.ServerSessionEndpoint

org.jboss.messaging.core.contract.Delivery

org.jboss.messaging.core.contract.Message

org.jboss.messaging.core.contract.MessageReference

org.jboss.messaging.core.impl.clusterconnection.MessageSucker

org.jboss.messaging.core.impl.postoffice.LoadBindings

org.jboss.messaging.core.impl.postoffice.MessagingPostOffice

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.