Examples of org.hornetq.core.client.impl.ClientSessionFactoryInternal

org.hornetq.core.client.impl.ClientSessionFactoryInternal
A ClientSessionFactoryInternal @author Tim Fox

   {
      locator.setBlockOnNonDurableSend(true);
      locator.setBlockOnDurableSend(true);
      locator.setFailoverOnInitialConnection(true);
      locator.setReconnectAttempts(-1);
      ClientSessionFactoryInternal sf = createSessionFactoryAndWaitForTopology(locator, 2);
      final CountDownLatch latch = new CountDownLatch(1);


      class MyListener implements SessionFailureListener
      {
         public void connectionFailed(final HornetQException me, boolean failedOver)
         {
            latch.countDown();
         }


         public void beforeReconnect(HornetQException exception)
         {
            System.out.println("MyListener.beforeReconnect");
         }
      }


      ClientSession session = sendAndConsume(sf, true);


      session.addFailureListener(new MyListener());


      backupServer.stop();


      liveServer.crash();


      beforeRestart(liveServer);


      // To reload security or other settings that are read during startup
      beforeRestart(liveServer);


      liveServer.start();


      assertTrue(latch.await(5, TimeUnit.SECONDS));


      ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);


      ClientMessage message = session.createMessage(true);


      setBody(0, message);


      producer.send(message);


      session.close();


      sf.close();


      Assert.assertEquals(0, sf.numSessions());


      Assert.assertEquals(0, sf.numConnections());
   }

View Full Code Here


      final double retryMultiplier = 1d;


      final int reconnectAttempts = -1;


      ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      ClientSession session = sf.createSession(false, true, true);


      session.createQueue(ReattachTest.ADDRESS, ReattachTest.ADDRESS, null, false);


      ClientProducer producer = session.createProducer(ReattachTest.ADDRESS);


      final int numMessages = 1000;


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = session.createMessage(HornetQTextMessage.TYPE,
                                                             false,
                                                             0,
                                                             System.currentTimeMillis(),
                                                             (byte)1);
         message.putIntProperty(new SimpleString("count"), i);
         message.getBodyBuffer().writeString("aardvarks");
         producer.send(message);
      }


      ClientConsumer consumer = session.createConsumer(ReattachTest.ADDRESS);


      InVMConnector.failOnCreateConnection = true;


      RemotingConnection conn = ((ClientSessionInternal)session).getConnection();


      Thread t = new Thread()
      {
         @Override
         public void run()
         {
            try
            {
               Thread.sleep(retryInterval * 3);
            }
            catch (InterruptedException ignore)
            {
            }


            InVMConnector.failOnCreateConnection = false;
         }
      };


      t.start();


      conn.fail(new HornetQException(HornetQException.NOT_CONNECTED));


      session.start();


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = consumer.receive(500);


         Assert.assertNotNull(message);


         Assert.assertEquals("aardvarks", message.getBodyBuffer().readString());


         Assert.assertEquals(i, message.getIntProperty("count").intValue());


         message.acknowledge();
      }


      ClientMessage message = consumer.receiveImmediate();


      Assert.assertNull(message);


      session.close();


      sf.close();


      t.join();
   }

View Full Code Here


      final int reconnectAttempts = -1;


      final long asyncFailDelay = 2000;


      ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      ClientSession session = sf.createSession(false, true, true);


      ClientSession session2 = sf.createSession(false, true, true);


      class MyFailureListener implements SessionFailureListener
      {
         volatile boolean failed;


         public void connectionFailed(final HornetQException me)
         {
            failed = true;
         }


         public void beforeReconnect(final HornetQException exception)
         {
         }
      }


      MyFailureListener listener = new MyFailureListener();


      session2.addFailureListener(listener);


      session.createQueue(ReattachTest.ADDRESS, ReattachTest.ADDRESS, null, false);


      ClientProducer producer = session.createProducer(ReattachTest.ADDRESS);


      final int numMessages = 1000;


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = session.createMessage(HornetQTextMessage.TYPE,
                                                             false,
                                                             0,
                                                             System.currentTimeMillis(),
                                                             (byte)1);
         message.putIntProperty(new SimpleString("count"), i);
         message.getBodyBuffer().writeString("aardvarks");
         producer.send(message);
      }


      ClientConsumer consumer = session.createConsumer(ReattachTest.ADDRESS);


      InVMConnector.numberOfFailures = 10;
      InVMConnector.failOnCreateConnection = true;


      final RemotingConnection conn = ((ClientSessionInternal)session).getConnection();


      final RemotingConnection conn2 = ((ClientSessionInternal)session2).getConnection();


      Thread t = new Thread()
      {
         @Override
         public void run()
         {
            try
            {
               Thread.sleep(asyncFailDelay);
            }
            catch (InterruptedException ignore)
            {
            }


            conn2.fail(new HornetQException(HornetQException.NOT_CONNECTED, "Did not receive pong from server"));
         }
      };


      t.start();


      conn.fail(new HornetQException(HornetQException.NOT_CONNECTED));


      Assert.assertTrue(listener.failed);


      session.start();


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = consumer.receive(500);


         Assert.assertNotNull(message);


         Assert.assertEquals("aardvarks", message.getBodyBuffer().readString());


         Assert.assertEquals(i, message.getIntProperty("count").intValue());


         message.acknowledge();
      }


      ClientMessage message = consumer.receiveImmediate();


      Assert.assertNull(message);


      session.close();


      session2.close();


      sf.close();


      t.join();
   }

View Full Code Here


      final double retryMultiplier = 1d;


      final int reconnectAttempts = 3;


      ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      ClientSession session = sf.createSession(false, true, true);


      session.createQueue(ReattachTest.ADDRESS, ReattachTest.ADDRESS, null, false);


      ClientProducer producer = session.createProducer(ReattachTest.ADDRESS);


      final int numMessages = 1000;


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = session.createMessage(HornetQTextMessage.TYPE,
                                                             false,
                                                             0,
                                                             System.currentTimeMillis(),
                                                             (byte)1);
         message.putIntProperty(new SimpleString("count"), i);
         message.getBodyBuffer().writeString("aardvarks");
         producer.send(message);
      }


      session.createConsumer(ReattachTest.ADDRESS);


      InVMConnector.failOnCreateConnection = true;


      RemotingConnection conn = ((ClientSessionInternal)session).getConnection();


      // Sleep for longer than max retries so should fail to reconnect


      Thread t = new Thread()
      {
         @Override
         public void run()
         {
            try
            {
               Thread.sleep(retryInterval * (reconnectAttempts + 1));
            }
            catch (InterruptedException ignore)
            {
            }


            InVMConnector.failOnCreateConnection = false;
         }
      };


      t.start();


      conn.fail(new HornetQException(HornetQException.NOT_CONNECTED));


      // Should throw exception since didn't reconnect


      try
      {
         session.start();


         Assert.fail("Should throw exception");
      }
      catch (HornetQException e)
      {
         Assert.assertEquals(HornetQException.OBJECT_CLOSED, e.getCode());
      }


      session.close();


      sf.close();


      t.join();
   }

View Full Code Here


         final double retryMultiplier = 1d;


         final int reconnectAttempts = -1;


         final ClientSessionFactoryInternal sf = createFactory(false);


         sf.setRetryInterval(retryInterval);
         sf.setRetryIntervalMultiplier(retryMultiplier);
         sf.setReconnectAttempts(reconnectAttempts);
         sf.setConfirmationWindowSize(1024 * 1024);


         session = sf.createSession();


         final RemotingConnection connFailure = ((ClientSessionInternal)session).getConnection();


         int numberOfThreads = 100;
         final int numberOfSessionsToCreate = 10;


         final CountDownLatch alignLatch = new CountDownLatch(numberOfThreads);
         final CountDownLatch startFlag = new CountDownLatch(1);


         class CreateSessionThread extends Thread
         {
            Throwable failure;


            @Override
            public void run()
            {
               try
               {
                  alignLatch.countDown();
                  startFlag.await();
                  for (int i = 0; i < numberOfSessionsToCreate; i++)
                  {
                     Thread.yield();
                     ClientSession session = sf.createSession(false, true, true);


                     session.close();
                  }
               }
               catch (Throwable e)
               {
                  e.printStackTrace();
                  failure = e;
               }
            }
         }


         CreateSessionThread threads[] = new CreateSessionThread[numberOfThreads];
         for (int i = 0; i < numberOfThreads; i++)
         {
            threads[i] = new CreateSessionThread();
            threads[i].start();
         }


         alignLatch.await();


         timer.schedule(new TimerTask()
         {
            @Override
            public void run()
            {
               try
               {
                  connFailure.fail(new HornetQException(HornetQException.NOT_CONNECTED));
               }
               catch (Exception e)
               {
                  ReattachTest.log.warn("Error on the timer " + e);
               }
            }


         }, 10, 10);


         startFlag.countDown();


         Throwable failure = null;


         for (CreateSessionThread thread : threads)
         {
            thread.join();
            if (thread.failure != null)
            {
               System.out.println("Thread " + thread.getName() + " failed - " + thread.failure);
               failure = thread.failure;
            }
         }


         if (failure != null)
         {
            throw failure;
         }


         sf.close();


      }
      finally
      {
         timer.cancel();

View Full Code Here


      final double retryMultiplier = 1d;


      final int reconnectAttempts = -1;


      final ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      InVMConnector.failOnCreateConnection = true;


      int numberOfThreads = 100;


      final CountDownLatch alignLatch = new CountDownLatch(numberOfThreads);
      final CountDownLatch startFlag = new CountDownLatch(1);


      class CreateSessionThread extends Thread
      {
         Throwable failure;


         @Override
         public void run()
         {
            try
            {
               alignLatch.countDown();
               startFlag.await();
               ClientSession session = sf.createSession(false, true, true);


               session.close();
            }
            catch (Throwable e)
            {
               e.printStackTrace();
               failure = e;
            }
         }
      }


      CreateSessionThread threads[] = new CreateSessionThread[numberOfThreads];
      for (int i = 0; i < numberOfThreads; i++)
      {
         threads[i] = new CreateSessionThread();
         threads[i].start();
      }


      // Sleep 3 times retryInterval, so it should at least have 3 retries


      Thread t = new Thread()
      {
         @Override
         public void run()
         {
            try
            {
               Thread.sleep(retryInterval * 3);
            }
            catch (InterruptedException ignore)
            {
            }


            InVMConnector.failOnCreateConnection = false;
         }
      };


      alignLatch.await();


      t.start();


      startFlag.countDown();


      Throwable failure = null;


      for (CreateSessionThread thread : threads)
      {
         thread.join();
         if (thread.failure != null)
         {
            System.out.println("Thread " + thread.getName() + " failed - " + thread.failure);
            failure = thread.failure;
         }
      }


      if (failure != null)
      {
         throw failure;
      }


      sf.close();


      t.join();
   }

View Full Code Here


      final double retryMultiplier = 1d;


      final int reconnectAttempts = -1;


      ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      ClientSession session = sf.createSession(false, true, true);


      // Sleep 3 times retryInterval, so it should at least have 3 retries


      RemotingConnection conn = ((ClientSessionInternal)session).getConnection();


      InVMConnector.failOnCreateConnection = false;


      conn.fail(new HornetQException(HornetQException.NOT_CONNECTED));


      Thread t = new Thread()
      {
         @Override
         public void run()
         {
            try
            {
               Thread.sleep(retryInterval * 3);
            }
            catch (InterruptedException ignore)
            {
            }


            InVMConnector.failOnCreateConnection = false;
         }
      };


      t.start();


      for (int i = 0; i < 10; i++)
      {
         session.createQueue("address", "queue" + i);
      }


      //
      // InVMConnector.failOnCreateConnection = true;


      //
      // //Should throw exception since didn't reconnect
      //      
      // try
      // {
      // session.start();
      //         
      // fail("Should throw exception");
      // }
      // catch (HornetQException e)
      // {
      // assertEquals(HornetQException.OBJECT_CLOSED, e.getCode());
      // }


      session.close();


      sf.close();


      t.join();
   }

View Full Code Here


      final double retryMultiplier = 1d;


      final int reconnectAttempts = 10;


      ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      ClientSession session = sf.createSession(false, true, true);


      session.createQueue(ReattachTest.ADDRESS, ReattachTest.ADDRESS, null, false);


      ClientProducer producer = session.createProducer(ReattachTest.ADDRESS);


      final int numMessages = 1000;


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = session.createMessage(HornetQTextMessage.TYPE,
                                                             false,
                                                             0,
                                                             System.currentTimeMillis(),
                                                             (byte)1);
         message.putIntProperty(new SimpleString("count"), i);
         message.getBodyBuffer().writeString("aardvarks");
         producer.send(message);
      }


      ClientConsumer consumer = session.createConsumer(ReattachTest.ADDRESS);


      InVMConnector.failOnCreateConnection = true;
      InVMConnector.numberOfFailures = reconnectAttempts - 1;


      RemotingConnection conn = ((ClientSessionInternal)session).getConnection();


      conn.fail(new HornetQException(HornetQException.NOT_CONNECTED));


      session.start();


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = consumer.receive(500);


         Assert.assertNotNull(message);


         Assert.assertEquals("aardvarks", message.getBodyBuffer().readString());


         Assert.assertEquals(i, message.getIntProperty("count").intValue());


         message.acknowledge();
      }


      ClientMessage message = consumer.receiveImmediate();


      Assert.assertNull(message);


      session.close();


      sf.close();
   }

View Full Code Here


      final double retryMultiplier = 1d;


      final int reconnectAttempts = -1;


      ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      ClientSession session = sf.createSession(false, true, true);


      session.createQueue(ReattachTest.ADDRESS, ReattachTest.ADDRESS, null, false);


      ClientProducer producer = session.createProducer(ReattachTest.ADDRESS);


      final int numMessages = 1000;


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = session.createMessage(HornetQTextMessage.TYPE,
                                                             false,
                                                             0,
                                                             System.currentTimeMillis(),
                                                             (byte)1);
         message.putIntProperty(new SimpleString("count"), i);
         message.getBodyBuffer().writeString("aardvarks");
         producer.send(message);
      }


      ClientConsumer consumer = session.createConsumer(ReattachTest.ADDRESS);


      InVMConnector.failOnCreateConnection = true;


      RemotingConnection conn = ((ClientSessionInternal)session).getConnection();


      long start = System.currentTimeMillis();


      Thread t = new Thread()
      {
         @Override
         public void run()
         {
            try
            {
               Thread.sleep(retryInterval / 2);
            }
            catch (InterruptedException ignore)
            {
            }
            InVMConnector.failOnCreateConnection = false;
         }
      };


      t.start();


      conn.fail(new HornetQException(HornetQException.NOT_CONNECTED));


      session.start();


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = consumer.receive(500);


         Assert.assertNotNull(message);


         Assert.assertEquals("aardvarks", message.getBodyBuffer().readString());


         Assert.assertEquals(i, message.getIntProperty("count").intValue());


         message.acknowledge();
      }


      ClientMessage message = consumer.receiveImmediate();


      Assert.assertNull(message);


      long end = System.currentTimeMillis();


      Assert.assertTrue(end - start >= retryInterval);


      session.close();


      sf.close();


      t.join();
   }

View Full Code Here


      final double retryMultiplier = 2d;


      final int reconnectAttempts = -1;


      ClientSessionFactoryInternal sf = createFactory(false);


      sf.setRetryInterval(retryInterval);
      sf.setRetryIntervalMultiplier(retryMultiplier);
      sf.setReconnectAttempts(reconnectAttempts);
      sf.setConfirmationWindowSize(1024 * 1024);


      ClientSession session = sf.createSession(false, true, true);


      session.createQueue(ReattachTest.ADDRESS, ReattachTest.ADDRESS, null, false);


      ClientProducer producer = session.createProducer(ReattachTest.ADDRESS);


      final int numMessages = 1000;


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = session.createMessage(HornetQTextMessage.TYPE,
                                                             false,
                                                             0,
                                                             System.currentTimeMillis(),
                                                             (byte)1);
         message.putIntProperty(new SimpleString("count"), i);
         message.getBodyBuffer().writeString("aardvarks");
         producer.send(message);
      }


      ClientConsumer consumer = session.createConsumer(ReattachTest.ADDRESS);


      InVMConnector.failOnCreateConnection = true;
      InVMConnector.numberOfFailures = 3;


      RemotingConnection conn = ((ClientSessionInternal)session).getConnection();


      long start = System.currentTimeMillis();


      conn.fail(new HornetQException(HornetQException.NOT_CONNECTED));


      session.start();


      for (int i = 0; i < numMessages; i++)
      {
         ClientMessage message = consumer.receive(500);


         Assert.assertNotNull(message);


         Assert.assertEquals("aardvarks", message.getBodyBuffer().readString());


         Assert.assertEquals(i, message.getObjectProperty(new SimpleString("count")));


         message.acknowledge();
      }


      ClientMessage message = consumer.receiveImmediate();


      Assert.assertNull(message);


      long end = System.currentTimeMillis();


      double wait = retryInterval + retryMultiplier * retryInterval + retryMultiplier * retryMultiplier * retryInterval;


      Assert.assertTrue(end - start >= wait);


      session.close();


      sf.close();
   }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hornetq.core.client.impl.ClientSessionFactoryInternal

org.hornetq.core.server.cluster.impl.BridgeImpl

org.hornetq.core.server.cluster.impl.ClusterConnectionBridge

org.hornetq.core.server.impl.HornetQServerImpl$SharedNothingBackupActivation

org.hornetq.core.server.impl.HornetQServerImpl$SharedNothingLiveActivation

org.hornetq.tests.integration.client.ServerLocatorConnectTest

org.hornetq.tests.integration.cluster.failover.FailBackAutoTest

org.hornetq.tests.integration.cluster.failover.FailBackManualTest

org.hornetq.tests.integration.cluster.failover.FailoverOnFlowControlTest

org.hornetq.tests.integration.cluster.failover.FailoverTest

org.hornetq.tests.integration.cluster.failover.FailoverTestBase

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.