Examples of org.jboss.messaging.core.plugin.contract.ClusteredPostOffice

Package org.jboss.messaging.core.plugin.contract

Examples of org.jboss.messaging.core.plugin.contract.ClusteredPostOffice

org.jboss.messaging.core.plugin.contract.ClusteredPostOffice
@author Tim Fox @author Clebert Suconic @version $Revision: 2319 $ $Id: ClusteredPostOffice.java 2319 2007-02-15 07:16:11Z ovidiu.feodorov@jboss.com $

         
         //Unbind it
    
         if (mDest.isClustered() && !postOffice.isLocal())
         {
            ClusteredPostOffice cpo = (ClusteredPostOffice)postOffice;
            
            cpo.unbindClusteredQueue(queueName);
         }
         else
         {         
            postOffice.unbindQueue(queueName);
         }

View Full Code Here

                                           mDest.getMaxSize(), selector, tr,
                                           mDest.getFullSize(),
                                           mDest.getPageSize(),
                                           mDest.getDownCacheSize());
               
               ClusteredPostOffice cpo = (ClusteredPostOffice)postOffice;


               binding = cpo.bindClusteredQueue(topicCond, (LocalClusteredQueue)q);
            }
            String counterName = TopicService.SUBSCRIPTION_MESSAGECOUNTER_PREFIX + q.getName();
  
            int dayLimitToUse = mDest.getMessageCounterHistoryDayLimit();
            if (dayLimitToUse == -1)
            {
               //Use override on server peer
               dayLimitToUse = sp.getDefaultMessageCounterHistoryDayLimit();
            }
            
            MessageCounter counter =
               new MessageCounter(counterName, null, q, 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 = postOffice.getBindingForQueueName(name);
            
            if (binding == null)
            {
               // Does not already exist
               
               if (trace) { log.trace(this + " creating new durable subscription on " + jmsDestination); }
                              
               PagingFilteredQueue q;


               if (postOffice.isLocal())
               {
                  q = new PagingFilteredQueue(name, idm.getID(), ms, pm, true, true,
                                              mDest.getMaxSize(), selector,
                                              mDest.getFullSize(),
                                              mDest.getPageSize(),
                                              mDest.getDownCacheSize());


                  binding = postOffice.bindQueue(topicCond, q);
               }
               else
               {
                  q = new LocalClusteredQueue((ClusteredPostOffice)postOffice, nodeId, name, idm.getID(),
                                              ms, pm, true, true,
                                              mDest.getMaxSize(), selector, tr,
                                              mDest.getFullSize(),
                                              mDest.getPageSize(),
                                              mDest.getDownCacheSize());
                  
                  ClusteredPostOffice cpo = (ClusteredPostOffice)postOffice;
                  
                  if (mDest.isClustered())
                  {
                     binding = cpo.bindClusteredQueue(topicCond, (LocalClusteredQueue)q);
                  }
                  else
                  {
                     binding = cpo.bindQueue(topicCond, q);
                  }
               }
               String counterName = TopicService.SUBSCRIPTION_MESSAGECOUNTER_PREFIX + q.getName();
                       
               MessageCounter counter =
                  new MessageCounter(counterName, subscriptionName, q, true, true,
                                     mDest.getMessageCounterHistoryDayLimit());
               
               sp.getMessageCounterManager().registerMessageCounter(counterName, counter);
            }
            else
            {
               //Durable sub already exists
               
               if (trace) { log.trace(this + " subscription " + subscriptionName + " already exists"); }
               
               // 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 =
                  binding.getQueue().getFilter() != null ?
                     binding.getQueue().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"); }
               
               JMSCondition cond = (JMSCondition)binding.getCondition();
               
               boolean topicChanged = !cond.getName().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
                  
                  if (mDest.isClustered() && !postOffice.isLocal())
                  {
                     ClusteredPostOffice cpo = (ClusteredPostOffice)postOffice;
                     
                     cpo.unbindClusteredQueue(name);
                  }
                  else
                  {
                     postOffice.unbindQueue(name);
                  }
                  
                  // create a fresh new subscription
                                    
                  PagingFilteredQueue q;
                  
                  if (postOffice.isLocal())
                  {
                     q = new PagingFilteredQueue(name, idm.getID(), ms, pm, true, true,
                              mDest.getMaxSize(), selector,
                              mDest.getFullSize(),
                              mDest.getPageSize(),
                              mDest.getDownCacheSize());
                     binding = postOffice.bindQueue(topicCond, q);
                  }
                  else
                  {
                     q = new LocalClusteredQueue((ClusteredPostOffice)postOffice, nodeId, name, idm.getID(), ms, pm, true, true,
                              mDest.getMaxSize(), selector, tr,
                              mDest.getFullSize(),
                              mDest.getPageSize(),
                              mDest.getDownCacheSize());
                     
                     ClusteredPostOffice cpo = (ClusteredPostOffice)postOffice;
                     
                     if (mDest.isClustered())
                     {
                        binding = cpo.bindClusteredQueue(topicCond, (LocalClusteredQueue)q);
                     }
                     else
                     {
                        binding = cpo.bindQueue(topicCond, (LocalClusteredQueue)q);
                     }
                  }
                  String counterName = TopicService.SUBSCRIPTION_MESSAGECOUNTER_PREFIX + q.getName();
                  
                  MessageCounter counter =

View Full Code Here

                                               destination.getDownCacheSize());
               postOffice.bindQueue(queueCond, queue);
            }
            else
            {
               ClusteredPostOffice cpo = (ClusteredPostOffice)postOffice;
               
               queue = new LocalClusteredQueue((ClusteredPostOffice)postOffice, nodeId, destination.getName(),
                        idm.getID(), ms, pm, true, true,
                        destination.getMaxSize(), null, tr,
                        destination.getFullSize(), destination.getPageSize(),
                        destination.getDownCacheSize());
               
               cpo.bindClusteredQueue(queueCond, (LocalClusteredQueue)queue);
               
            }                             
         }
         
         ((ManagedQueue)destination).setQueue(queue);

View Full Code Here

   
   protected void notLocal(boolean persistent) throws Throwable
   {
      log.info("not local:" + persistent);
      
      ClusteredPostOffice office1 = null;
      
      ClusteredPostOffice office2 = null;
      
      ClusteredPostOffice office3 = null;
      
      ClusteredPostOffice office4 = null;
      
      ClusteredPostOffice office5 = null;
      
      ClusteredPostOffice office6 = null;
          
      try
      {   
         office1 = createClusteredPostOfficeWithRRR(1, "testgroup", sc, ms, pm, tr);
         
         office2 = createClusteredPostOfficeWithRRR(2, "testgroup", sc, ms, pm, tr);
         
         office3 = createClusteredPostOfficeWithRRR(3, "testgroup", sc, ms, pm, tr);
         
         office4 = createClusteredPostOfficeWithRRR(4, "testgroup", sc, ms, pm, tr);
         
         office5 = createClusteredPostOfficeWithRRR(5, "testgroup", sc, ms, pm, tr);
         
         office6 = createClusteredPostOfficeWithRRR(6, "testgroup", sc, ms, pm, tr);
         
         LocalClusteredQueue queue1 =
            new LocalClusteredQueue(office1, 1, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office1.bindClusteredQueue(new SimpleCondition("topic"), queue1);
         SimpleReceiver receiver1 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue1.add(receiver1);
         
         LocalClusteredQueue queue2 =
            new LocalClusteredQueue(office2, 2, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office2.bindClusteredQueue(new SimpleCondition("topic"), queue2);
         SimpleReceiver receiver2 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue2.add(receiver2);
         
         LocalClusteredQueue queue3 =
            new LocalClusteredQueue(office3, 3, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office3.bindClusteredQueue(new SimpleCondition("topic"), queue3);
         SimpleReceiver receiver3 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue3.add(receiver3);
         
         LocalClusteredQueue queue4 =
            new LocalClusteredQueue(office4, 4, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office4.bindClusteredQueue(new SimpleCondition("topic"), queue4);
         SimpleReceiver receiver4 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue4.add(receiver4);
         
         LocalClusteredQueue queue5 =
            new LocalClusteredQueue(office5, 5, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office5.bindClusteredQueue(new SimpleCondition("topic"), queue5);
         SimpleReceiver receiver5 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue5.add(receiver5);
         
         LocalClusteredQueue queue6 =
            new LocalClusteredQueue(office6, 6, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office6.bindClusteredQueue(new SimpleCondition("topic"), queue6);
         SimpleReceiver receiver6 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue6.add(receiver6);
         
         log.info("setup");
               
         List msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkContainsAndAcknowledge(msgs, receiver1, queue1);         
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         checkEmpty(receiver6);
         
         log.info("1");
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkContainsAndAcknowledge(msgs, receiver2, queue1);                  
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         checkEmpty(receiver6);
         
         log.info("2");
         
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkEmpty(receiver2);
         checkContainsAndAcknowledge(msgs, receiver3, queue1);                           
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         checkEmpty(receiver6);
         
         log.info("3");
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkContainsAndAcknowledge(msgs, receiver4, queue1);                                    
         checkEmpty(receiver5);
         checkEmpty(receiver6);
         
         
         
         log.info("4");
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkContainsAndAcknowledge(msgs, receiver5, queue1); 
         checkEmpty(receiver6);
         
         
         log.info("5");
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);       
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         checkContainsAndAcknowledge(msgs, receiver6, queue1); 
         
         log.info("6");
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkContainsAndAcknowledge(msgs, receiver1, queue1);      
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         checkEmpty(receiver6);
         log.info("7");
                     
      }
      finally
      {
         if (office1 != null)
         {            
            try
            {
               office1.stop();
            }
            catch (Exception ignore)
            {
               
            }
         }
         
         if (office2 != null)
         {
            try
            {
               office2.stop();
            }
            catch (Exception ignore)
            {
               
            }
         }
         
         if (office3 != null)
         {            
            try
            {
               office3.stop();
            }
            catch (Exception ignore)
            {
               
            }
         }
         
         if (office4 != null)
         {
            try
            {
               office4.stop();
            }
            catch (Exception ignore)
            {
               
            }
         }
         
         if (office5 != null)
         {            
            try
            {
               office5.stop();
            }
            catch (Exception ignore)
            {
               
            }
         }
         
         if (office6 != null)
         {
            try
            {
               office6.stop();
            }
            catch (Exception ignore)
            {
               
            }

View Full Code Here

      local(false);
   }
   
   protected void notLocal(boolean persistent) throws Throwable
   {
      ClusteredPostOffice office1 = null;
      
      ClusteredPostOffice office2 = null;
      
      ClusteredPostOffice office3 = null;
      
      ClusteredPostOffice office4 = null;
      
      ClusteredPostOffice office5 = null;
      
      ClusteredPostOffice office6 = null;
          
      try
      {   
         office1 = createClusteredPostOffice(1, "testgroup", sc, ms, pm, tr);
         
         office2 = createClusteredPostOffice(2, "testgroup", sc, ms, pm, tr);
         
         office3 = createClusteredPostOffice(3, "testgroup", sc, ms, pm, tr);
         
         office4 = createClusteredPostOffice(4, "testgroup", sc, ms, pm, tr);
         
         office5 = createClusteredPostOffice(5, "testgroup", sc, ms, pm, tr);
         
         office6 = createClusteredPostOffice(6, "testgroup", sc, ms, pm, tr);
         
         LocalClusteredQueue queue1 =
            new LocalClusteredQueue(office2, 2, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office2.bindClusteredQueue(new SimpleCondition("topic"), queue1);
         SimpleReceiver receiver1 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue1.add(receiver1);
         
         LocalClusteredQueue queue2 =
            new LocalClusteredQueue(office3, 3, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office3.bindClusteredQueue(new SimpleCondition("topic"), queue2);
         SimpleReceiver receiver2 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue2.add(receiver2);
         
         LocalClusteredQueue queue3 =
            new LocalClusteredQueue(office4, 4, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office4.bindClusteredQueue(new SimpleCondition("topic"), queue3);
         SimpleReceiver receiver3 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue3.add(receiver3);
         
         LocalClusteredQueue queue4 =
            new LocalClusteredQueue(office5, 5, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office5.bindClusteredQueue(new SimpleCondition("topic"), queue4);
         SimpleReceiver receiver4 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue4.add(receiver4);
         
         LocalClusteredQueue queue5 =
            new LocalClusteredQueue(office6, 6, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office6.bindClusteredQueue(new SimpleCondition("topic"), queue5);
         SimpleReceiver receiver5 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue5.add(receiver5);
               
         List msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkContainsAndAcknowledge(msgs, receiver1, queue1);         
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkContainsAndAcknowledge(msgs, receiver2, queue1);                  
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkEmpty(receiver2);
         checkContainsAndAcknowledge(msgs, receiver3, queue1);                           
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkContainsAndAcknowledge(msgs, receiver4, queue1);                                    
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkContainsAndAcknowledge(msgs, receiver5, queue1); 
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkContainsAndAcknowledge(msgs, receiver1, queue1);         
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office1, 1, null);         
         checkEmpty(receiver1);
         checkContainsAndAcknowledge(msgs, receiver2, queue1);                  
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
                     
      }
      finally
      {
         if (office1 != null)
         {            
            office1.stop();
         }
         
         if (office2 != null)
         {
            office2.stop();
         }
         
         if (office3 != null)
         {            
            office3.stop();
         }
         
         if (office4 != null)
         {
            office4.stop();
         }
         
         if (office5 != null)
         {            
            office5.stop();
         }
         
         if (office6 != null)
         {
            office6.stop();
         }
      }
   }

View Full Code Here

   
   
   
   protected void local(boolean persistent) throws Throwable
   {
      ClusteredPostOffice office1 = null;
      ClusteredPostOffice office2 = null;
      ClusteredPostOffice office3 = null;
      ClusteredPostOffice office4 = null;
      ClusteredPostOffice office5 = null;
      ClusteredPostOffice office6 = null;
          
      try
      {   
         office1 = createClusteredPostOffice(1, "testgroup", sc, ms, pm, tr);
         office2 = createClusteredPostOffice(2, "testgroup", sc, ms, pm, tr);
         office3 = createClusteredPostOffice(3, "testgroup", sc, ms, pm, tr);
         office4 = createClusteredPostOffice(4, "testgroup", sc, ms, pm, tr);
         office5 = createClusteredPostOffice(5, "testgroup", sc, ms, pm, tr);
         office6 = createClusteredPostOffice(6, "testgroup", sc, ms, pm, tr);
         
         LocalClusteredQueue queue1 =
            new LocalClusteredQueue(office2, 2, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office2.bindClusteredQueue(new SimpleCondition("topic"), queue1);
         SimpleReceiver receiver1 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue1.add(receiver1);
         
         LocalClusteredQueue queue2 =
            new LocalClusteredQueue(office3, 3, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office3.bindClusteredQueue(new SimpleCondition("topic"), queue2);
         SimpleReceiver receiver2 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue2.add(receiver2);
         
         LocalClusteredQueue queue3 =
            new LocalClusteredQueue(office4, 4, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office4.bindClusteredQueue(new SimpleCondition("topic"), queue3);
         SimpleReceiver receiver3 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue3.add(receiver3);
         
         LocalClusteredQueue queue4 =
            new LocalClusteredQueue(office5, 5, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office5.bindClusteredQueue(new SimpleCondition("topic"), queue4);
         SimpleReceiver receiver4 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue4.add(receiver4);
         
         LocalClusteredQueue queue5 =
            new LocalClusteredQueue(office6, 6, "queue1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office6.bindClusteredQueue(new SimpleCondition("topic"), queue5);
         SimpleReceiver receiver5 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         queue5.add(receiver5);
               
         List msgs = sendMessages("topic", persistent, office2, 3, null);         
         checkContainsAndAcknowledge(msgs, receiver1, queue1);         
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office2, 3, null);         
         checkContainsAndAcknowledge(msgs, receiver1, queue1);         
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office2, 3, null);         
         checkContainsAndAcknowledge(msgs, receiver1, queue1);         
         checkEmpty(receiver2);
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         
         msgs = sendMessages("topic", persistent, office3, 3, null); 
         checkEmpty(receiver1);
         checkContainsAndAcknowledge(msgs, receiver2, queue1);                  
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office3, 3, null); 
         checkEmpty(receiver1);
         checkContainsAndAcknowledge(msgs, receiver2, queue1);                  
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
         msgs = sendMessages("topic", persistent, office3, 3, null); 
         checkEmpty(receiver1);
         checkContainsAndAcknowledge(msgs, receiver2, queue1);                  
         checkEmpty(receiver3);
         checkEmpty(receiver4);
         checkEmpty(receiver5);
         
                     
      }
      finally
      {
         if (office1 != null)
         {            
            office1.stop();
         }
         
         if (office2 != null)
         {
            office2.stop();
         }
         
         if (office3 != null)
         {            
            office3.stop();
         }
         
         if (office4 != null)
         {
            office4.stop();
         }
         
         if (office5 != null)
         {            
            office5.stop();
         }
         
         if (office6 != null)
         {
            office6.stop();
         }
      }
   }

View Full Code Here

   /**
    * Clustered post offices should be able to have local queues bound to them too.
    */
   protected void routeLocalQueues(boolean persistentMessage, boolean recoverable) throws Throwable
   {
      ClusteredPostOffice office1 = null;
      ClusteredPostOffice office2 = null;
      ClusteredPostOffice office3 = null;
                    
      try
      {   
         office1 = createClusteredPostOffice(1, "testgroup", sc, ms, pm, tr);
         office2 = createClusteredPostOffice(2, "testgroup", sc, ms, pm, tr);
         office3 = createClusteredPostOffice(3, "testgroup", sc, ms, pm, tr);


         LocalClusteredQueue sub1 =
            new LocalClusteredQueue(office1, 1, "sub1", channelIDManager.getID(), ms, pm, true,
                                    recoverable, -1, null, tr);


         office1.bindQueue(new SimpleCondition("topic"), sub1);


         SimpleReceiver receiver1 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sub1.add(receiver1);
         
         LocalClusteredQueue sub2 =
            new LocalClusteredQueue(office2, 2, "sub2", channelIDManager.getID(), ms, pm, true,
                                    recoverable, -1, null, tr);


         office2.bindQueue(new SimpleCondition("topic"), sub2);
         SimpleReceiver receiver2 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sub2.add(receiver2);
         
         LocalClusteredQueue sub3 =
            new LocalClusteredQueue(office3, 3, "sub3", channelIDManager.getID(), ms, pm, true,
                                    recoverable, -1, null, tr);


         office3.bindQueue(new SimpleCondition("topic"), sub3);
         SimpleReceiver receiver3 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sub3.add(receiver3);
         
         //Only the local sub should get it since we have bound locally
         
         Message msg = CoreMessageFactory.createCoreMessage(1, persistentMessage, null);      
         MessageReference ref = ms.reference(msg);         
         boolean routed = office1.route(ref, new SimpleCondition("topic"), null);         
         assertTrue(routed);         
         Thread.sleep(500);         
         checkContainsAndAcknowledge(msg, receiver1, sub1);
         this.checkEmpty(receiver2);
         this.checkEmpty(receiver3);
         
         msg = CoreMessageFactory.createCoreMessage(2, persistentMessage, null);      
         ref = ms.reference(msg);         
         routed = office2.route(ref, new SimpleCondition("topic"), null);         
         assertTrue(routed);                  
         Thread.sleep(500);
         this.checkEmpty(receiver1);
         checkContainsAndAcknowledge(msg, receiver2, sub2);
         this.checkEmpty(receiver3);
         
         msg = CoreMessageFactory.createCoreMessage(3, persistentMessage, null);      
         ref = ms.reference(msg);         
         routed = office3.route(ref, new SimpleCondition("topic"), null);           
         assertTrue(routed);         
         Thread.sleep(500);
         this.checkEmpty(receiver1);         
         this.checkEmpty(receiver2);
         checkContainsAndAcknowledge(msg, receiver3, sub2);           
                         
         if (checkNoMessageData())
         {
            fail("Message data still in database");
         }
         
      }
      finally
      {
         if (office1 != null)
         {            
            office1.stop();
         }
         
         if (office2 != null)
         {
            office2.stop();
         }
         
         if (office3 != null)
         {            
            office3.stop();
         }
         
      }
   }

View Full Code Here

    * 
    * Then we send mess
    */
   protected void routeComplexTopic(boolean persistent) throws Throwable
   {
      ClusteredPostOffice office1 = null;
      ClusteredPostOffice office2 = null;
      ClusteredPostOffice office3 = null;
      ClusteredPostOffice office4 = null;
      ClusteredPostOffice office5 = null;
      ClusteredPostOffice office6 = null;
      ClusteredPostOffice office7 = null;
        
      try
      {   
         office1 = createClusteredPostOffice(1, "testgroup", sc, ms, pm, tr);
         office2 = createClusteredPostOffice(2, "testgroup", sc, ms, pm, tr);
         office3 = createClusteredPostOffice(3, "testgroup", sc, ms, pm, tr);
         office4 = createClusteredPostOffice(4, "testgroup", sc, ms, pm, tr);
         office5 = createClusteredPostOffice(5, "testgroup", sc, ms, pm, tr);
         office6 = createClusteredPostOffice(6, "testgroup", sc, ms, pm, tr);
         office7 = createClusteredPostOffice(7, "testgroup", sc, ms, pm, tr);
         
         //Node 2
         //======
         
         // Non durable 1 on node 2
         LocalClusteredQueue nonDurable1 =
            new LocalClusteredQueue(office2, 2, "nondurable1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);


         office2.bindClusteredQueue(new SimpleCondition("topic"), nonDurable1);
         SimpleReceiver receiver1 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonDurable1.add(receiver1);
         
         // Non durable 2 on node 2
         LocalClusteredQueue nonDurable2 =
            new LocalClusteredQueue(office2, 2, "nondurable2", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);


         office2.bindClusteredQueue(new SimpleCondition("topic"), nonDurable2);
         SimpleReceiver receiver2 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonDurable2.add(receiver2);
         
         //Node 3
         //======
         
         // Non shared durable
         LocalClusteredQueue nonSharedDurable1 =
            new LocalClusteredQueue(office3, 3, "nonshareddurable1", channelIDManager.getID(), ms,
                                    pm, true, true, -1, null, tr);


         office3.bindClusteredQueue(new SimpleCondition("topic"), nonSharedDurable1);
         SimpleReceiver receiver3 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonSharedDurable1.add(receiver3);
         
         // Non durable
         LocalClusteredQueue nonDurable3 =
            new LocalClusteredQueue(office3, 3, "nondurable3", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);


         office3.bindClusteredQueue(new SimpleCondition("topic"), nonDurable3);
         SimpleReceiver receiver4 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonDurable3.add(receiver4);
         
         //Node 4
         //======
         
         // Shared durable
         LocalClusteredQueue sharedDurable1 =
            new LocalClusteredQueue(office4, 4, "shareddurable1", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);


         office4.bindClusteredQueue(new SimpleCondition("topic"), sharedDurable1);
         SimpleReceiver receiver5 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sharedDurable1.add(receiver5);
         
         // Non shared durable
         LocalClusteredQueue nonSharedDurable2 =
            new LocalClusteredQueue(office4, 4, "nonshareddurable2", channelIDManager.getID(), ms,
                                    pm, true, true, -1, null, tr);


         office4.bindClusteredQueue(new SimpleCondition("topic"), nonSharedDurable2);
         SimpleReceiver receiver6 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonSharedDurable2.add(receiver6);
         
         // Non durable
         LocalClusteredQueue nonDurable4 =
            new LocalClusteredQueue(office4, 4, "nondurable4", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);


         office4.bindClusteredQueue(new SimpleCondition("topic"), nonDurable4);
         SimpleReceiver receiver7 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonDurable4.add(receiver7);
         
         // Non durable
         LocalClusteredQueue nonDurable5 =
            new LocalClusteredQueue(office4, 4, "nondurable5", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office4.bindClusteredQueue(new SimpleCondition("topic"), nonDurable5);
         SimpleReceiver receiver8 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonDurable5.add(receiver8);
         
         // Non durable
         LocalClusteredQueue nonDurable6 =
            new LocalClusteredQueue(office4, 4, "nondurable6", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office4.bindClusteredQueue(new SimpleCondition("topic"), nonDurable6);
         SimpleReceiver receiver9 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonDurable6.add(receiver9);
         
         // Node 5
         //=======
         // Shared durable
         LocalClusteredQueue sharedDurable2 =
            new LocalClusteredQueue(office5, 5, "shareddurable1", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);


         office5.bindClusteredQueue(new SimpleCondition("topic"), sharedDurable2);
         SimpleReceiver receiver10 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sharedDurable2.add(receiver10);
         
         // Shared durable
         LocalClusteredQueue sharedDurable3 =
            new LocalClusteredQueue(office5, 5, "shareddurable2", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);


         office5.bindClusteredQueue(new SimpleCondition("topic"), sharedDurable3);
         SimpleReceiver receiver11 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sharedDurable3.add(receiver11);
         
         // Node 6
         //=========
         LocalClusteredQueue sharedDurable4 =
            new LocalClusteredQueue(office6, 6, "shareddurable2", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);


         office6.bindClusteredQueue(new SimpleCondition("topic"), sharedDurable4);
         SimpleReceiver receiver12 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sharedDurable4.add(receiver12);
         
         LocalClusteredQueue nonDurable7 =
            new LocalClusteredQueue(office6, 6, "nondurable7", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         office6.bindClusteredQueue(new SimpleCondition("topic"), nonDurable7);
         SimpleReceiver receiver13 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         nonDurable7.add(receiver13);
         
         //Node 7
         //=======
         LocalClusteredQueue sharedDurable5 =
            new LocalClusteredQueue(office7, 7, "shareddurable2", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);


         office7.bindClusteredQueue(new SimpleCondition("topic"), sharedDurable5);
         SimpleReceiver receiver14 = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
         sharedDurable5.add(receiver14);
         
         
         //Send 1 message at node1
         //========================
         
         List msgs = sendMessages("topic", persistent, office1, 1, null);
         
         //n2
         checkContainsAndAcknowledge(msgs, receiver1, nonDurable1);
         checkContainsAndAcknowledge(msgs, receiver2, nonDurable2);
         
         //n3
         checkContainsAndAcknowledge(msgs, receiver3, nonSharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver4, nonDurable3);
         
         //n4
         checkContainsAndAcknowledge(msgs, receiver5, sharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver6, nonSharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver7, nonDurable4);
         checkContainsAndAcknowledge(msgs, receiver8, nonDurable5);
         checkContainsAndAcknowledge(msgs, receiver9, nonDurable6);
         
         //n5
         checkEmpty(receiver10);
         checkContainsAndAcknowledge(msgs, receiver11, sharedDurable3);
         
         //n6
         checkEmpty(receiver12);
         checkContainsAndAcknowledge(msgs, receiver13, nonDurable7);
         
         //n7
         checkEmpty(receiver14);
         
         
         //Send 1 message at node2
         //========================
         
         msgs = sendMessages("topic", persistent, office2, 1, null);
         
         //n2
         checkContainsAndAcknowledge(msgs, receiver1, nonDurable1);
         checkContainsAndAcknowledge(msgs, receiver2, nonDurable2);
         
         //n3
         checkContainsAndAcknowledge(msgs, receiver3, nonSharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver4, nonDurable3);
         
         //n4
         checkContainsAndAcknowledge(msgs, receiver5, sharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver6, nonSharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver7, nonDurable4);
         checkContainsAndAcknowledge(msgs, receiver8, nonDurable5);
         checkContainsAndAcknowledge(msgs, receiver9, nonDurable6);
         
         //n5
         checkEmpty(receiver10);
         checkContainsAndAcknowledge(msgs, receiver11, sharedDurable3);
         
         //n6
         checkEmpty(receiver12);
         checkContainsAndAcknowledge(msgs, receiver13, nonDurable7);
         
         //n7
         checkEmpty(receiver14);
         
         //Send 1 message at node3
         //========================
         
         msgs = sendMessages("topic", persistent, office3, 1, null);
         
         //n2
         checkContainsAndAcknowledge(msgs, receiver1, nonDurable1);
         checkContainsAndAcknowledge(msgs, receiver2, nonDurable2);
         
         //n3
         checkContainsAndAcknowledge(msgs, receiver3, nonSharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver4, nonDurable3);
         
         //n4
         checkContainsAndAcknowledge(msgs, receiver5, sharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver6, nonSharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver7, nonDurable4);
         checkContainsAndAcknowledge(msgs, receiver8, nonDurable5);
         checkContainsAndAcknowledge(msgs, receiver9, nonDurable6);
         
         //n5
         checkEmpty(receiver10);
         checkContainsAndAcknowledge(msgs, receiver11, sharedDurable3);
         
         //n6
         checkEmpty(receiver12);
         checkContainsAndAcknowledge(msgs, receiver13, nonDurable7);
         
         //n7
         checkEmpty(receiver14);     
         
         //Send 1 message at node4
         //========================
         
         msgs = sendMessages("topic", persistent, office4, 1, null);         
               
         //n2
         checkContainsAndAcknowledge(msgs, receiver1, nonDurable1);
         checkContainsAndAcknowledge(msgs, receiver2, nonDurable2);
         
         //n3
         checkContainsAndAcknowledge(msgs, receiver3, nonSharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver4, nonDurable3);
         
         //n4
         checkContainsAndAcknowledge(msgs, receiver5, sharedDurable1); // shared durable 1
         checkContainsAndAcknowledge(msgs, receiver6, nonSharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver7, nonDurable4);
         checkContainsAndAcknowledge(msgs, receiver8, nonDurable5);
         checkContainsAndAcknowledge(msgs, receiver9, nonDurable6);
         
         //n5
         checkEmpty(receiver10);       //shared durable 1
         checkContainsAndAcknowledge(msgs, receiver11, sharedDurable3);     //shared durable 2    
         
         //n6
         checkEmpty(receiver12); // shared durable 2
         checkContainsAndAcknowledge(msgs, receiver13, nonDurable7); 
         
         //n7
         checkEmpty(receiver14);
         
         //Send 1 message at node5
         //========================
         
         msgs = sendMessages("topic", persistent, office5, 1, null);
             
         //n2
         checkContainsAndAcknowledge(msgs, receiver1, nonDurable1);
         checkContainsAndAcknowledge(msgs, receiver2, nonDurable2);
         
         //n3
         checkContainsAndAcknowledge(msgs, receiver3, nonSharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver4, nonDurable3);
         
         //n4
         checkEmpty(receiver5);
         checkContainsAndAcknowledge(msgs, receiver6, nonSharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver7, nonDurable4);
         checkContainsAndAcknowledge(msgs, receiver8, nonDurable5);
         checkContainsAndAcknowledge(msgs, receiver9, nonDurable6);
         
         //n5
         checkContainsAndAcknowledge(msgs, receiver10, sharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver11, sharedDurable3);
         
         //n6
         checkEmpty(receiver12);
         checkContainsAndAcknowledge(msgs, receiver13, nonDurable7);
         
         //n7
         checkEmpty(receiver12);
         
         //Send 1 message at node6
         //========================
         
         msgs = sendMessages("topic", persistent, office6, 1, null);
             
         //n2
         checkContainsAndAcknowledge(msgs, receiver1, nonDurable1);
         checkContainsAndAcknowledge(msgs, receiver2, nonDurable2);
         
         //n3
         checkContainsAndAcknowledge(msgs, receiver3, nonSharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver4, nonDurable3);
         
         //n4
         checkContainsAndAcknowledge(msgs, receiver5, sharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver6, nonSharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver7, nonDurable4);
         checkContainsAndAcknowledge(msgs, receiver8, nonDurable5);
         checkContainsAndAcknowledge(msgs, receiver9, nonDurable6);
         
         //n5
         checkEmpty(receiver10);
        
         checkEmpty(receiver11);
         
         //n6
         checkContainsAndAcknowledge(msgs, receiver12, sharedDurable4);         
         checkContainsAndAcknowledge(msgs, receiver13, nonDurable7);
         
         //n7
         checkEmpty(receiver12);
         
         //Send 1 message at node7
         //========================
         
         msgs = sendMessages("topic", persistent, office7, 1, null);


         //n2
         checkContainsAndAcknowledge(msgs, receiver1, nonDurable1);
         checkContainsAndAcknowledge(msgs, receiver2, nonDurable2);
         
         //n3
         checkContainsAndAcknowledge(msgs, receiver3, nonSharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver4, nonDurable3);
         
         //n4
         checkContainsAndAcknowledge(msgs, receiver5, sharedDurable1);
         checkContainsAndAcknowledge(msgs, receiver6, nonSharedDurable2);
         checkContainsAndAcknowledge(msgs, receiver7, nonDurable4);
         checkContainsAndAcknowledge(msgs, receiver8, nonDurable5);
         checkContainsAndAcknowledge(msgs, receiver9, nonDurable6);
         
         //n5
         checkEmpty(receiver10);
         checkEmpty(receiver11);
         
         //n6
         checkEmpty(receiver12);
         checkContainsAndAcknowledge(msgs, receiver13, nonDurable7);
         
         //n7
         checkContainsAndAcknowledge(msgs, receiver14, sharedDurable5);
         
         if (checkNoMessageData())
         {
            fail("Message data still in database");
         }        
      }
      finally
      {
         if (office1 != null)
         {            
            office1.stop();
         }
         
         if (office2 != null)
         {
            office2.stop();
         }
         
         if (office3 != null)
         {            
            try
            {
               office3.unbindClusteredQueue("nonshareddurable1");
            }
            catch (Exception ignore)
            {   
               ignore.printStackTrace();
            }
            office3.stop();
         }
         
         if (office4 != null)
         {
            try
            {
               office4.unbindClusteredQueue("shareddurable1");
               office4.unbindClusteredQueue("nonshareddurable2");
            }
            catch (Exception ignore)
            {           
               ignore.printStackTrace();
            }
            office4.stop();
         }
         
         if (office5 != null)
         {      
            try
            {
               office5.unbindClusteredQueue("shareddurable1");
               office5.unbindClusteredQueue("shareddurable2");
            }
            catch (Exception ignore)
            {               
               ignore.printStackTrace();
            }
            office5.stop();
         }
         
         if (office6 != null)
         {         
            try
            {
               office6.unbindClusteredQueue("shareddurable2");
            }
            catch (Exception ignore)
            {               
               ignore.printStackTrace();
            }
            office6.stop();
         }
         
         if (office7 != null)
         {      
            try
            {
               office7.unbindClusteredQueue("shareddurable2");
            }
            catch (Exception ignore)
            {               
               ignore.printStackTrace();
            }
            office7.stop();
         }
        
      }
   }

View Full Code Here


   
   
   protected void clusteredTransactionalRoute(boolean persistent) throws Throwable
   {
      ClusteredPostOffice office1 = null;
      
      ClusteredPostOffice office2 = null;
      
      try
      {   
         //Start two offices
         
         office1 = createClusteredPostOffice(1, "testgroup", sc, ms, pm, tr);
         office2 = createClusteredPostOffice(2, "testgroup", sc, ms, pm, tr);
     
         LocalClusteredQueue[] queues = new LocalClusteredQueue[16];
         Binding[] bindings = new Binding[16];
         
         queues[0] =
            new LocalClusteredQueue(office1, 1, "sub1", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[0] = office1.bindClusteredQueue(new SimpleCondition("topic1"), queues[0]);
         
         queues[1] =
            new LocalClusteredQueue(office1, 1, "sub2", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[1] = office1.bindClusteredQueue(new SimpleCondition("topic1"), queues[1]);
         
         queues[2] =
            new LocalClusteredQueue(office2, 2, "sub3", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[2] = office2.bindClusteredQueue(new SimpleCondition("topic1"), queues[2]);
         
         queues[3] =
            new LocalClusteredQueue(office2, 2, "sub4", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[3] = office2.bindClusteredQueue(new SimpleCondition("topic1"), queues[3]);
         
         queues[4] =
            new LocalClusteredQueue(office2, 2, "sub5", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);
         bindings[4] = office2.bindClusteredQueue(new SimpleCondition("topic1"), queues[4]);
         
         queues[5] =
            new LocalClusteredQueue(office1, 1, "sub6", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[5] = office1.bindClusteredQueue(new SimpleCondition("topic1"), queues[5]);
         
         queues[6] =
            new LocalClusteredQueue(office1, 1, "sub7", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);
         bindings[6] = office1.bindClusteredQueue(new SimpleCondition("topic1"), queues[6]);
         
         queues[7] =
            new LocalClusteredQueue(office1, 1, "sub8", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);
         bindings[7] = office1.bindClusteredQueue(new SimpleCondition("topic1"), queues[7]);
         
         queues[8] =
            new LocalClusteredQueue(office1, 1, "sub9", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[8] = office1.bindClusteredQueue(new SimpleCondition("topic2"), queues[8]);
         
         queues[9] =
            new LocalClusteredQueue(office1, 1, "sub10", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[9] = office1.bindClusteredQueue(new SimpleCondition("topic2"), queues[9]);
         
         queues[10] =
            new LocalClusteredQueue(office2, 2, "sub11", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[10] = office2.bindClusteredQueue(new SimpleCondition("topic2"), queues[10]);
         
         queues[11] =
            new LocalClusteredQueue(office2, 2, "sub12", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[11] = office2.bindClusteredQueue(new SimpleCondition("topic2"), queues[11]);
         
         queues[12] =
            new LocalClusteredQueue(office2, 2, "sub13", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);
         bindings[12] = office2.bindClusteredQueue(new SimpleCondition("topic2"), queues[12]);
         
         queues[13] =
            new LocalClusteredQueue(office1, 1, "sub14", channelIDManager.getID(), ms, pm,
                                    true, false, -1, null, tr);
         bindings[13] = office1.bindClusteredQueue(new SimpleCondition("topic2"), queues[13]);
         
         queues[14] =
            new LocalClusteredQueue(office1, 1, "sub15", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);
         bindings[14] = office1.bindClusteredQueue(new SimpleCondition("topic2"), queues[14]);
         
         queues[15] =
            new LocalClusteredQueue(office1, 1, "sub16", channelIDManager.getID(), ms, pm,
                                    true, true, -1, null, tr);
         bindings[15] = office1.bindClusteredQueue(new SimpleCondition("topic2"), queues[15]);


         SimpleReceiver[] receivers = new SimpleReceiver[16];
         
         for (int i = 0; i < 16; i++)
         {
            receivers[i] = new SimpleReceiver("blah", SimpleReceiver.ACCEPTING);
            queues[i].add(receivers[i]);
         }
         
         //First for topic 1
         
         Message msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);;      
         MessageReference ref1 = ms.reference(msg1);
         
         Message msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);;      
         MessageReference ref2 = ms.reference(msg2);
         
         Transaction tx = tr.createTransaction();


         boolean routed = office1.route(ref1, new SimpleCondition("topic1"), tx);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic1"), tx);         
         assertTrue(routed);


         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         tx.commit();
         
         //Messages are sent asych so may take some finite time to arrive
         Thread.sleep(1000);
         
         for (int i = 0; i < 8; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());            
            receivers[i].acknowledge(msgRec1, null);
            receivers[i].acknowledge(msgRec2, null);
            msgs = queues[i].browse();
            assertNotNull(msgs);            
            assertTrue(msgs.isEmpty());                        
            receivers[i].clear();
         }
         
         for (int i = 8; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);;      
         ref1 = ms.reference(msg1);
         
         msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);;      
         ref2 = ms.reference(msg2);
         
         tx = tr.createTransaction();


         routed = office1.route(ref1, new SimpleCondition("topic1"), tx);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic1"), tx);         
         assertTrue(routed);
         
         //Messages are sent asych so may take some finite time to arrive
         Thread.sleep(1000);         
         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         tx.rollback();
         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         //Now send some non transactionally
         
         msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);
         ref1 = ms.reference(msg1);
         
         msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);
         ref2 = ms.reference(msg2);
         
         routed = office1.route(ref1, new SimpleCondition("topic1"), null);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic1"), null);         
         assertTrue(routed);
         
         //Messages are sent asych so may take some finite time to arrive
         Thread.sleep(1000);         
         
         //And acknowledge transactionally
         
         tx = tr.createTransaction();
         
         for (int i = 0; i < 8; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());      
                        
            receivers[i].acknowledge(msgRec1, tx);
            receivers[i].acknowledge(msgRec2, tx);
             
            int deliveringCount = queues[i].getDeliveringCount();
            
            assertEquals(2, deliveringCount);
                       
            receivers[i].clear();
         }
         
         for (int i = 8; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         tx.commit();
         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         
         // and the rollback
         
         msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);;      
         ref1 = ms.reference(msg1);
         
         msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);;      
         ref2 = ms.reference(msg2);
         
         routed = office1.route(ref1, new SimpleCondition("topic1"), null);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic1"), null);         
         assertTrue(routed);
         
         Thread.sleep(1000);
                 
         tx = tr.createTransaction();
         
         for (int i = 0; i < 8; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());      
                        
            receivers[i].acknowledge(msgRec1, tx);
            receivers[i].acknowledge(msgRec2, tx);
               
            int deliveringCount = queues[i].getDeliveringCount();
            
            assertEquals(2, deliveringCount);
            
         }
         
         for (int i = 8; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         tx.rollback();
         
         for (int i = 0; i < 8; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());      
                                 
            int deliveringCount = queues[i].getDeliveringCount();
            
            assertEquals(2, deliveringCount);
            
            receivers[i].acknowledge(msgRec1, null);
            receivers[i].acknowledge(msgRec2, null);
                           
            receivers[i].clear();
         }
         
         for (int i = 8; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         
         // Now for topic 2
         
         msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);    
         ref1 = ms.reference(msg1);
         
         msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);     
         ref2 = ms.reference(msg2);
         
         tx = tr.createTransaction();


         routed = office1.route(ref1, new SimpleCondition("topic2"), tx);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic2"), tx);         
         assertTrue(routed);
         
         
         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         tx.commit();
         
         //Messages are sent asych so may take some finite time to arrive
         Thread.sleep(1000);
         
         for (int i = 0; i < 8; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         for (int i = 8; i < 16; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());            
            receivers[i].acknowledge(msgRec1, null);
            receivers[i].acknowledge(msgRec2, null);
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty()); 
            receivers[i].clear();
         }
         
         msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);;      
         ref1 = ms.reference(msg1);
         
         msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);;      
         ref2 = ms.reference(msg2);
         
         tx = tr.createTransaction();


         routed = office1.route(ref1, new SimpleCondition("topic1"), tx);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic1"), tx);         
         assertTrue(routed);
         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         tx.rollback();
         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         //Now send some non transactionally
         
         msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);      
         ref1 = ms.reference(msg1);
         
         msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);      
         ref2 = ms.reference(msg2);
         
         routed = office1.route(ref1, new SimpleCondition("topic2"), null);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic2"), null);         
         assertTrue(routed);
         
         Thread.sleep(1000);
         
         //And acknowledge transactionally
         
         tx = tr.createTransaction();
         
         for (int i = 0; i < 8; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         for (int i = 8; i < 16; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());      
                        
            receivers[i].acknowledge(msgRec1, tx);
            receivers[i].acknowledge(msgRec2, tx);
                        
            int deliveringCount = queues[i].getDeliveringCount();
            
            assertEquals(2, deliveringCount);
            
            receivers[i].clear();
         }
         
         
         
         tx.commit();
         
         for (int i = 0; i < 16; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         
         // and the rollback
         
         msg1 = CoreMessageFactory.createCoreMessage(1, persistent, null);;      
         ref1 = ms.reference(msg1);
         
         msg2 = CoreMessageFactory.createCoreMessage(2, persistent, null);;      
         ref2 = ms.reference(msg2);
         
         routed = office1.route(ref1, new SimpleCondition("topic2"), null);         
         assertTrue(routed);
         routed = office1.route(ref2, new SimpleCondition("topic2"), null);         
         assertTrue(routed);
         
         Thread.sleep(1000);
          
         tx = tr.createTransaction();
         
         for (int i = 0; i < 8; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         for (int i = 8; i < 16; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());      
            
            
            receivers[i].acknowledge(msgRec1, tx);
            receivers[i].acknowledge(msgRec2, tx);
            
            
            int deliveringCount = queues[i].getDeliveringCount();
            
            assertEquals(2, deliveringCount);
         }
         
         
         
         tx.rollback();
         
         for (int i = 0; i < 8; i++)
         {
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
            msgs = queues[i].browse();
            assertNotNull(msgs);
            assertTrue(msgs.isEmpty());
         }
         
         for (int i = 8; i < 16; i++)
         {         
            List msgs = receivers[i].getMessages();
            assertNotNull(msgs);
            assertEquals(2, msgs.size());
            Message msgRec1 = (Message)msgs.get(0);
            assertEquals(msg1.getMessageID(), msgRec1.getMessageID());
            Message msgRec2 = (Message)msgs.get(1);
            assertEquals(msg2.getMessageID(), msgRec2.getMessageID());      
                                              
            int deliveringCount = queues[i].getDeliveringCount();
            
            assertEquals(2, deliveringCount);
            
            receivers[i].acknowledge(msgRec1, null);
            receivers[i].acknowledge(msgRec2, null);             
            
            receivers[i].clear();
         }
         if (checkNoMessageData())
         {
            fail("Message data still in database");
         }
      }
      finally
      {
         if (office1 != null)
         {
            try
            {
               office1.unbindClusteredQueue("sub7");
               office1.unbindClusteredQueue("sub8");           
               office1.unbindClusteredQueue("sub15");
               office1.unbindClusteredQueue("sub16");
            }
            catch (Exception ignore)
            {
               ignore.printStackTrace();
            }
                        
            office1.stop();
         }
         
         if (office2 != null)
         {
            try
            {
               office2.unbindClusteredQueue("sub5");
               office2.unbindClusteredQueue("sub13");
            }
            catch (Exception ignore)
            {
               ignore.printStackTrace();
            }
            
            office2.stop();
         }
      }
   }

View Full Code Here


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


   public final void testSimpleJoinLeave() throws Throwable
   {
      ClusteredPostOffice office1 = null;
      ClusteredPostOffice office2 = null;
      ClusteredPostOffice office3 = null;
      
      try
      {         
         log.trace("Starting office 1");
         office1 = createClusteredPostOffice(1, "testgroup", sc, ms, pm, tr);


         log.trace("starting office 2");
         office2 = createClusteredPostOffice(2, "testgroup", sc, ms, pm, tr);
                  
         office3 = createClusteredPostOffice(3, "testgroup", sc, ms, pm, tr);
         
         Thread.sleep(2000);
         
         office1.stop();
         office1 = null;
         
         office2.stop();
         office2 = null;
         
         office3.stop();
         office3 = null;
      }
      finally
      {
         if (office1 != null)
         {
            office1.stop();
         }
         
         if (office2 != null)
         {
            office2.stop();
         }
         
         if (office3 != null)
         {
            office3.stop();
         }
         
//         if (checkNoBindingData())
//         {
//            fail("data still in database");

View Full Code Here

0 1

TOP

Related Classes of org.jboss.messaging.core.plugin.contract.ClusteredPostOffice

org.jboss.jms.server.destination.QueueService

org.jboss.jms.server.endpoint.ServerSessionEndpoint

org.jboss.test.messaging.core.plugin.postoffice.cluster.DefaultClusteredPostOfficeTest

org.jboss.test.messaging.core.plugin.postoffice.cluster.DefaultClusteredPostOfficeWithDefaultRouterTest

org.jboss.test.messaging.core.plugin.postoffice.cluster.DefaultClusteredPostOfficeWithRoundRobinRouterTest

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.