Examples of org.hornetq.jms.bridge.impl.JMSBridgeImpl

org.hornetq.jms.bridge.impl.JMSBridgeImpl
A JMSBridge @author Tim Fox @version $Revision:4566 $ $Id:JMSBridge.java 4566 2008-06-24 08:01:35Z jmesnil $

    * Send some more messages
    * Verify all messages are received
    */
   private void testCrashAndReconnectDestCrashBeforePrepare(final boolean persistent) throws Exception
   {
      JMSBridgeImpl bridge = null;


      try
      {
         bridge = new JMSBridgeImpl(cff0xa,
                                    cff1xa,
                                    sourceQueueFactory,
                                    targetQueueFactory,
                                    null,
                                    null,
                                    null,
                                    null,
                                    null,
                                    1000,
                                    -1,
                                    QualityOfServiceMode.ONCE_AND_ONLY_ONCE,
                                    10,
                                    5000,
                                    null,
                                    null,
                                    false);
         bridge.setTransactionManager(newTransactionManager());


         bridge.start();


         final int NUM_MESSAGES = 10;
         // Send some messages


         sendMessages(cf0, sourceQueue, 0, NUM_MESSAGES / 2, persistent, false);


         // verify none are received


         checkEmpty(targetQueue, 1);


         // Now crash the dest server


         JMSBridgeReconnectionTest.log.info("About to crash server");


         jmsServer1.stop();


         // Wait a while before starting up to simulate the dest being down for a while
         JMSBridgeReconnectionTest.log.info("Waiting 5 secs before bringing server back up");
         Thread.sleep(TIME_WAIT);
         JMSBridgeReconnectionTest.log.info("Done wait");


         // Restart the server
         jmsServer1.start();


         createQueue("targetQueue", 1);


         setUpAdministeredObjects();


         sendMessages(cf0, sourceQueue, NUM_MESSAGES / 2, NUM_MESSAGES / 2, persistent, false);


         checkMessagesReceived(cf1, targetQueue, QualityOfServiceMode.ONCE_AND_ONLY_ONCE, NUM_MESSAGES, false, false);
      }
      finally
      {


         if (bridge != null)
         {
            try
            {
               bridge.stop();
            }
            catch (Exception e)
            {
               JMSBridgeReconnectionTest.log.error("Failed to stop bridge", e);
            }

View Full Code Here

      ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
      DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
      DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
      TransactionManager tm = JMSBridgeImplTest.newTransactionManager();


      JMSBridgeImpl bridge = new JMSBridgeImpl();


      bridge.setSourceConnectionFactoryFactory(sourceCFF);
      bridge.setSourceDestinationFactory(sourceDF);
      bridge.setTargetConnectionFactoryFactory(targetCFF);
      bridge.setTargetDestinationFactory(targetDF);
      // retry after 10 ms
      bridge.setFailureRetryInterval(10);
      // retry only once
      bridge.setMaxRetries(1);
      bridge.setMaxBatchSize(1);
      bridge.setMaxBatchTime(-1);
      bridge.setTransactionManager(tm);
      bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);


      Assert.assertFalse(bridge.isStarted());
      bridge.start();


      Thread.sleep(50);
      Assert.assertFalse(bridge.isStarted());
      Assert.assertTrue(bridge.isFailed());
      
      bridge.stop();


   }

View Full Code Here

      ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
      DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
      DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
      TransactionManager tm = JMSBridgeImplTest.newTransactionManager();


      JMSBridgeImpl bridge = new JMSBridgeImpl();


      bridge.setSourceConnectionFactoryFactory(sourceCFF);
      bridge.setSourceDestinationFactory(sourceDF);
      bridge.setTargetConnectionFactoryFactory(targetCFF);
      bridge.setTargetDestinationFactory(targetDF);
      // retry after 10 ms
      bridge.setFailureRetryInterval(10);
      // retry only once
      bridge.setMaxRetries(1);
      bridge.setMaxBatchSize(1);
      bridge.setMaxBatchTime(-1);
      bridge.setTransactionManager(tm);
      bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);


      Assert.assertFalse(bridge.isStarted());
      bridge.start();


      Thread.sleep(500);
      Assert.assertTrue(bridge.isStarted());
      Assert.assertFalse(bridge.isFailed());


      bridge.stop();
   }

View Full Code Here

      ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
      DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
      DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
      TransactionManager tm = JMSBridgeImplTest.newTransactionManager();


      JMSBridgeImpl bridge = new JMSBridgeImpl();
      Assert.assertNotNull(bridge);


      bridge.setSourceConnectionFactoryFactory(sourceCFF);
      bridge.setSourceDestinationFactory(sourceDF);
      bridge.setTargetConnectionFactoryFactory(targetCFF);
      bridge.setTargetDestinationFactory(targetDF);
      bridge.setFailureRetryInterval(10);
      bridge.setMaxRetries(-1);
      bridge.setMaxBatchSize(maxBatchSize);
      bridge.setMaxBatchTime(maxBatchTime);
      bridge.setTransactionManager(tm);
      bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);


      Assert.assertFalse(bridge.isStarted());
      bridge.start();
      Assert.assertTrue(bridge.isStarted());


      Connection targetConn = JMSBridgeImplTest.createConnectionFactory().createConnection();
      Session targetSess = targetConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageConsumer consumer = targetSess.createConsumer(targetDF.createDestination());
      final List<Message> messages = new LinkedList<Message>();
      MessageListener listener = new MessageListener()
      {


         public void onMessage(final Message message)
         {
            messages.add(message);
         }
      };
      consumer.setMessageListener(listener);
      targetConn.start();


      Connection sourceConn = JMSBridgeImplTest.createConnectionFactory().createConnection();
      Session sourceSess = sourceConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageProducer producer = sourceSess.createProducer(sourceDF.createDestination());
      producer.send(sourceSess.createTextMessage());
      sourceConn.close();


      Assert.assertEquals(0, messages.size());
      Thread.sleep(3 * maxBatchTime);


      Assert.assertEquals(1, messages.size());


      bridge.stop();
      Assert.assertFalse(bridge.isStarted());


      targetConn.close();
   }

View Full Code Here

      ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
      DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
      DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
      TransactionManager tm = JMSBridgeImplTest.newTransactionManager();


      JMSBridgeImpl bridge = new JMSBridgeImpl();
      Assert.assertNotNull(bridge);


      bridge.setSourceConnectionFactoryFactory(sourceCFF);
      bridge.setSourceDestinationFactory(sourceDF);
      bridge.setTargetConnectionFactoryFactory(targetCFF);
      bridge.setTargetDestinationFactory(targetDF);
      bridge.setFailureRetryInterval(10);
      bridge.setMaxRetries(-1);
      bridge.setMaxBatchSize(numMessages);
      bridge.setMaxBatchTime(-1);
      bridge.setTransactionManager(tm);
      bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);


      Assert.assertFalse(bridge.isStarted());
      bridge.start();
      Assert.assertTrue(bridge.isStarted());


      Connection targetConn = JMSBridgeImplTest.createConnectionFactory().createConnection();
      Session targetSess = targetConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageConsumer consumer = targetSess.createConsumer(targetDF.createDestination());
      final List<Message> messages = new LinkedList<Message>();
      final CountDownLatch latch = new CountDownLatch(numMessages);
      MessageListener listener = new MessageListener()
      {
         public void onMessage(final Message message)
         {
            messages.add(message);
            latch.countDown();
         }
      };
      consumer.setMessageListener(listener);
      targetConn.start();


      Connection sourceConn = JMSBridgeImplTest.createConnectionFactory().createConnection();
      Session sourceSess = sourceConn.createSession(false, Session.AUTO_ACKNOWLEDGE);


      MessageProducer producer = sourceSess.createProducer(sourceDF.createDestination());


      for (int i = 0; i < numMessages - 1; i++)
      {
         TextMessage msg = sourceSess.createTextMessage();
         producer.send(msg);
         JMSBridgeImplTest.log.info("sent message " + i);
      }


      Thread.sleep(1000);


      Assert.assertEquals(0, messages.size());


      TextMessage msg = sourceSess.createTextMessage();


      producer.send(msg);


      Assert.assertTrue(latch.await(10000, TimeUnit.MILLISECONDS));


      sourceConn.close();


      Assert.assertEquals(numMessages, messages.size());


      bridge.stop();
      Assert.assertFalse(bridge.isStarted());


      targetConn.close();
   }

View Full Code Here

      ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
      DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
      DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
      TransactionManager tm = JMSBridgeImplTest.newTransactionManager();


      JMSBridgeImpl bridge = new JMSBridgeImpl();
      Assert.assertNotNull(bridge);


      bridge.setSourceConnectionFactoryFactory(sourceCFF);
      bridge.setSourceDestinationFactory(sourceDF);
      bridge.setTargetConnectionFactoryFactory(targetCFF);
      bridge.setTargetDestinationFactory(targetDF);
      bridge.setFailureRetryInterval(10);
      bridge.setMaxRetries(2);
      bridge.setMaxBatchSize(1);
      bridge.setMaxBatchTime(-1);
      bridge.setTransactionManager(tm);
      bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);


      Assert.assertFalse(bridge.isStarted());
      bridge.start();
      Assert.assertTrue(bridge.isStarted());


      sourceConn.get().getExceptionListener().onException(new JMSException("exception on the source"));
      Thread.sleep(4 * bridge.getFailureRetryInterval());
      // reconnection must have succeeded
      Assert.assertTrue(bridge.isStarted());


      bridge.stop();
      Assert.assertFalse(bridge.isStarted());
   }

View Full Code Here

      ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
      DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
      DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(HornetQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
      TransactionManager tm = JMSBridgeImplTest.newTransactionManager();


      JMSBridgeImpl bridge = new JMSBridgeImpl();
      Assert.assertNotNull(bridge);


      bridge.setSourceConnectionFactoryFactory(sourceCFF);
      bridge.setSourceDestinationFactory(sourceDF);
      bridge.setTargetConnectionFactoryFactory(targetCFF);
      bridge.setTargetDestinationFactory(targetDF);
      bridge.setFailureRetryInterval(100);
      bridge.setMaxRetries(1);
      bridge.setMaxBatchSize(1);
      bridge.setMaxBatchTime(-1);
      bridge.setTransactionManager(tm);
      bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);


      Assert.assertFalse(bridge.isStarted());
      bridge.start();
      Assert.assertTrue(bridge.isStarted());


      sourceConn.get().getExceptionListener().onException(new JMSException("exception on the source"));
      Thread.sleep(4 * bridge.getFailureRetryInterval());
      // reconnection must have failed
      Assert.assertFalse(bridge.isStarted());


   }

View Full Code Here


   public void testStartBridgeFirst() throws Exception
   {
      //stop the source server, we want to start the bridge first
      jmsServer0.stop();
      JMSBridgeImpl bridge = null;


      ConnectionFactoryFactory factInUse0 = cff0;
      ConnectionFactoryFactory factInUse1 = cff1;
      try
      {
         final int NUM_MESSAGES = 10;


         bridge = new JMSBridgeImpl(factInUse0,
                                    factInUse1,
                                    sourceQueueFactory,
                                    targetQueueFactory,
                                    null,
                                    null,
                                    null,
                                    null,
                                    null,
                                    5000,
                                    10,
                                    QualityOfServiceMode.AT_MOST_ONCE,
                                    NUM_MESSAGES,
                                    -1,
                                    null,
                                    null,
                                    false);
         bridge.setTransactionManager(newTransactionManager());


         bridge.start();


         //now start the server
         jmsServer0.start();
         createQueue("sourceQueue", 0);
         createQueue("localTargetQueue", 0);
         jmsServer0.createTopic(false, "sourceTopic", "/topic/sourceTopic");
         // Send half the messges


         sendMessages(cf0, sourceQueue, 0, NUM_MESSAGES / 2, false, false);


         // Verify none are received


         checkEmpty(targetQueue, 1);


         // Send the other half


         sendMessages(cf0, sourceQueue, NUM_MESSAGES / 2, NUM_MESSAGES / 2, false, false);


         // This should now be receivable


         checkAllMessageReceivedInOrder(cf1, targetQueue, 0, NUM_MESSAGES, false);


         // Send another batch with one more than batch size


         sendMessages(cf0, sourceQueue, 0, NUM_MESSAGES + 1, false, false);


         // Make sure only batch size are received


         checkAllMessageReceivedInOrder(cf1, targetQueue, 0, NUM_MESSAGES, false);


         // Final batch


         sendMessages(cf0, sourceQueue, 0, NUM_MESSAGES - 1, false, false);


         checkAllMessageReceivedInOrder(cf1, targetQueue, NUM_MESSAGES, 1, false);


         checkAllMessageReceivedInOrder(cf1, targetQueue, 0, NUM_MESSAGES - 1, false);
      }
      finally
      {
         if (bridge != null)
         {
            JMSBridgeTest.log.info("Stopping bridge");
            bridge.stop();
         }
      }
   }

View Full Code Here

   }




   public void testParams() throws Exception
   {
      JMSBridgeImpl bridge = null;


      try
      {
         QualityOfServiceMode qosMode = QualityOfServiceMode.AT_MOST_ONCE;


         int batchSize = 10;


         int maxBatchTime = -1;


         String sourceUsername = null;


         String sourcePassword = null;


         String destUsername = null;


         String destPassword = null;


         String selector = null;


         long failureRetryInterval = 5000;


         int maxRetries = 10;


         String subName = null;


         String clientID = null;


         try
         {
            bridge = new JMSBridgeImpl(null,
                                       cff1,
                                       sourceQueueFactory,
                                       targetQueueFactory,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       failureRetryInterval,
                                       maxRetries,
                                       qosMode,
                                       batchSize,
                                       maxBatchTime,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }


         try
         {
            bridge = new JMSBridgeImpl(cff0,
                                       null,
                                       sourceQueueFactory,
                                       targetQueueFactory,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       failureRetryInterval,
                                       maxRetries,
                                       qosMode,
                                       batchSize,
                                       maxBatchTime,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }


         try
         {
            bridge = new JMSBridgeImpl(cff0,
                                       cff1,
                                       null,
                                       targetQueueFactory,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       failureRetryInterval,
                                       maxRetries,
                                       qosMode,
                                       batchSize,
                                       maxBatchTime,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }


         try
         {
            bridge = new JMSBridgeImpl(cff0,
                                       cff1,
                                       sourceQueueFactory,
                                       null,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       failureRetryInterval,
                                       maxRetries,
                                       qosMode,
                                       batchSize,
                                       maxBatchTime,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }


         try
         {
            bridge = new JMSBridgeImpl(cff0,
                                       cff1,
                                       sourceQueueFactory,
                                       targetQueueFactory,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       -2,
                                       maxRetries,
                                       qosMode,
                                       batchSize,
                                       maxBatchTime,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }


         try
         {
            bridge = new JMSBridgeImpl(cff0,
                                       cff1,
                                       sourceQueueFactory,
                                       targetQueueFactory,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       -1,
                                       10,
                                       qosMode,
                                       batchSize,
                                       maxBatchTime,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }


         try
         {
            bridge = new JMSBridgeImpl(cff0,
                                       cff1,
                                       sourceQueueFactory,
                                       null,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       failureRetryInterval,
                                       maxRetries,
                                       qosMode,
                                       0,
                                       maxBatchTime,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }


         try
         {
            bridge = new JMSBridgeImpl(cff0,
                                       cff1,
                                       sourceQueueFactory,
                                       null,
                                       sourceUsername,
                                       sourcePassword,
                                       destUsername,
                                       destPassword,
                                       selector,
                                       failureRetryInterval,
                                       maxRetries,
                                       qosMode,
                                       batchSize,
                                       -2,
                                       subName,
                                       clientID,
                                       false);
         }
         catch (IllegalArgumentException e)
         {
            // Ok
         }
      }
      finally
      {
         if (bridge != null)
         {
            bridge.stop();
         }
      }
   }

View Full Code Here

      }
   }


   public void testStartStopStart() throws Exception
   {
      JMSBridgeImpl bridge = null;


      Connection connSource = null;


      Connection connTarget = null;


      try
      {
         final int NUM_MESSAGES = 10;


         bridge = new JMSBridgeImpl(cff0,
                                    cff1,
                                    sourceQueueFactory,
                                    targetQueueFactory,
                                    null,
                                    null,
                                    null,
                                    null,
                                    null,
                                    5000,
                                    10,
                                    QualityOfServiceMode.AT_MOST_ONCE,
                                    1,
                                    -1,
                                    null,
                                    null,
                                    false);
         bridge.setTransactionManager(newTransactionManager());


         bridge.start();


         bridge.stop();
         
         bridge.start();
         
         connSource = cf0.createConnection();


         Session sessSend = connSource.createSession(false, Session.AUTO_ACKNOWLEDGE);


         MessageProducer prod = sessSend.createProducer(sourceQueue);


         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm = sessSend.createTextMessage("message" + i);
            prod.send(tm);
         }


         connTarget = cf1.createConnection();
         Session sessRec = connTarget.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageConsumer cons = sessRec.createConsumer(targetQueue);


         connTarget.start();


         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm = (TextMessage)cons.receive(10000);
            Assert.assertNotNull(tm);
            Assert.assertEquals("message" + i, tm.getText());
         }


         Message m = cons.receiveNoWait();
         Assert.assertNull(m);
      }
      finally
      {
         if (connSource != null)
         {
            connSource.close();
         }


         if (connTarget != null)
         {
            connTarget.close();
         }


         if (bridge != null)
         {
            bridge.stop();
         }


         removeAllMessages(sourceQueue.getQueueName(), 0);
      }
   }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hornetq.jms.bridge.impl.JMSBridgeImpl

org.hornetq.api.core.client.ClientSession

org.hornetq.api.core.client.FailoverEventType

org.hornetq.jms.client.HornetQConnection

org.hornetq.jms.client.HornetQConnectionFactory

org.hornetq.jms.client.HornetQSession

org.hornetq.tests.integration.jms.bridge.JMSBridgeReconnectionTest

org.hornetq.tests.integration.jms.bridge.JMSBridgeTest

org.hornetq.tests.timing.jms.bridge.impl.JMSBridgeImplTest

org.hornetq.utils.DefaultSensitiveStringCodec

org.jboss.as.messaging.jms.bridge.JMSBridgeAdd

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.