Java ClientSession.addFailureListener方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public static void crashAndWaitForFailure(ActiveMQServer server, ClientSession... sessions) throws Exception {
   CountDownLatch latch = new CountDownLatch(sessions.length);
   for (ClientSession session : sessions) {
      CountDownSessionFailureListener listener = new CountDownSessionFailureListener(latch, session);
      session.addFailureListener(listener);
   }

   ClusterManager clusterManager = server.getClusterManager();
   clusterManager.flushExecutor();
   clusterManager.clear();
   Assert.assertTrue("server should be running!", server.isStarted());
   server.fail(true);

   if (sessions.length > 0) {
      // Wait to be informed of failure
      boolean ok = latch.await(10000, TimeUnit.MILLISECONDS);
      Assert.assertTrue("Failed to stop the server! Latch count is " + latch.getCount() + " out of " +
                           sessions.length, ok);
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testFailureListener() throws Exception {

   cf = createSessionFactory(locator);
   ClientSession clientSession = addClientSession(cf.createSession(false, true, true));
   CountDownSessionFailureListener listener = new CountDownSessionFailureListener(clientSession);
   clientSession.addFailureListener(listener);
   // Make sure failure listener is called if server is stopped without session being closed first
   server.stop();
   Assert.assertTrue(listener.getLatch().await(5, TimeUnit.SECONDS));
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * Basic fail-back test.
 *
 * @throws Exception
 */
@Test
public void testFailBack() throws Exception {
   ((SharedStoreSlavePolicy) backupServer.getServer().getHAPolicy()).setRestartBackup(false);
   createSessionFactory();
   ClientSession session = sendAndConsume(sf, true);

   ClientProducer producer = session.createProducer(ADDRESS);

   sendMessages(session, producer, NUM_MESSAGES);
   session.commit();

   crash(session);

   session.start();
   ClientConsumer consumer = session.createConsumer(ADDRESS);
   receiveMessages(consumer, 0, NUM_MESSAGES, true);
   producer = session.createProducer(ADDRESS);
   sendMessages(session, producer, 2 * NUM_MESSAGES);
   session.commit();
   assertFalse("must NOT be a backup", liveServer.getServer().getHAPolicy().isBackup());
   adaptLiveConfigForReplicatedFailBack(liveServer);

   CountDownSessionFailureListener listener = new CountDownSessionFailureListener(session);
   session.addFailureListener(listener);

   liveServer.start();

   assertTrue(listener.getLatch().await(5, TimeUnit.SECONDS));
   assertTrue("live initialized after restart", liveServer.getServer().waitForActivation(15, TimeUnit.SECONDS));

   session.start();
   receiveMessages(consumer, 0, NUM_MESSAGES, true);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * Connect to the server if not already done so
 *
 * @return the connectionFactory XAResource
 * @throws Exception for any problem
 */
protected XAResource connect() throws Exception {
   // Do we already have a valid connectionFactory?
   synchronized (ActiveMQXAResourceWrapper.lock) {
      if (delegate != null) {
         return delegate;
      }
   }

   for (XARecoveryConfig xaRecoveryConfig : xaRecoveryConfigs) {

      if (xaRecoveryConfig == null) {
         continue;
      }
      if (ActiveMQXARecoveryLogger.LOGGER.isDebugEnabled()) {
         ActiveMQXARecoveryLogger.LOGGER.debug("Trying to connect recovery on " + xaRecoveryConfig + " of " + Arrays.toString(xaRecoveryConfigs));
      }

      ClientSession cs = null;

      try {
         // setting ha=false because otherwise the connector would go towards any server, causing Heuristic exceptions
         // we really need to control what server it's connected to

         // Manual configuration may still use discovery, so we will keep this
         if (xaRecoveryConfig.getDiscoveryConfiguration() != null) {
            serverLocator = ActiveMQClient.createServerLocator(false, xaRecoveryConfig.getDiscoveryConfiguration());
         } else {
            serverLocator = ActiveMQClient.createServerLocator(false, xaRecoveryConfig.getTransportConfig());
         }
         serverLocator.disableFinalizeCheck();
         serverLocator.setProtocolManagerFactory(xaRecoveryConfig.getClientProtocolManager());
         csf = serverLocator.createSessionFactory();
         if (xaRecoveryConfig.getUsername() == null) {
            cs = csf.createSession(true, false, false);
         } else {
            cs = csf.createSession(xaRecoveryConfig.getUsername(), xaRecoveryConfig.getPassword(), true, false, false, false, 1);
         }
      } catch (Throwable e) {
         ActiveMQXARecoveryLogger.LOGGER.xaRecoverAutoConnectionError(e, xaRecoveryConfig);
         if (ActiveMQXARecoveryLogger.LOGGER.isDebugEnabled()) {
            ActiveMQXARecoveryLogger.LOGGER.debug(e.getMessage(), e);
         }

         try {
            if (cs != null)
               cs.close();
            if (serverLocator != null)
               serverLocator.close();
         } catch (Throwable ignored) {
            if (ActiveMQXARecoveryLogger.LOGGER.isTraceEnabled()) {
               ActiveMQXARecoveryLogger.LOGGER.trace(e.getMessage(), ignored);
            }
         }
         continue;
      }

      cs.addFailureListener(this);

      synchronized (ActiveMQXAResourceWrapper.lock) {
         delegate = cs;
      }

      return delegate;
   }
   ActiveMQXARecoveryLogger.LOGGER.recoveryConnectFailed(Arrays.toString(xaRecoveryConfigs));
   throw new ActiveMQNotConnectedException();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testServerFailureNoPing() throws Exception {
   TransportConfiguration transportConfig = new TransportConfiguration(INVM_CONNECTOR_FACTORY);
   ServerLocator locator = addServerLocator(ActiveMQClient.createServerLocatorWithoutHA(transportConfig));
   locator.setClientFailureCheckPeriod(PingTest.CLIENT_FAILURE_CHECK_PERIOD);
   locator.setConnectionTTL(PingTest.CLIENT_FAILURE_CHECK_PERIOD * 2);
   ClientSessionFactoryImpl csf = (ClientSessionFactoryImpl) createSessionFactory(locator);

   Listener clientListener = new Listener();

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

   Assert.assertEquals(1, csf.numConnections());

   session.addFailureListener(clientListener);

   // We need to get it to stop pinging after one

   csf.stopPingingAfterOne();

   RemotingConnection serverConn = null;

   while (serverConn == null) {
      Set<RemotingConnection> conns = server.getRemotingService().getConnections();

      if (!conns.isEmpty()) {
         serverConn = server.getRemotingService().getConnections().iterator().next();
      } else {
         // It's async so need to wait a while
         Thread.sleep(10);
      }
   }

   Listener serverListener = new Listener();

   serverConn.addFailureListener(serverListener);

   for (int i = 0; i < 1000; i++) {
      // a few tries to avoid a possible race caused by GCs or similar issues
      if (server.getRemotingService().getConnections().isEmpty() && clientListener.getException() != null) {
         break;
      }

      Thread.sleep(10);
   }

   if (!server.getRemotingService().getConnections().isEmpty()) {
      RemotingConnection serverConn2 = server.getRemotingService().getConnections().iterator().next();

      PingTest.log.info("Serverconn2 is " + serverConn2);
   }

   Assert.assertTrue(server.getRemotingService().getConnections().isEmpty());

   // The client listener should be called too since the server will close it from the server side which will result
   // in the
   // netty detecting closure on the client side and then calling failure listener
   Assert.assertNotNull(clientListener.getException());

   Assert.assertNotNull(serverListener.getException());

   session.close();

   csf.close();

   locator.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * @param session
 * @throws InterruptedException
 */
private void fail(final ClientSession session) throws InterruptedException {

   final CountDownLatch latch = new CountDownLatch(1);

   session.addFailureListener(new CountDownSessionFailureListener(latch, session));

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

   // Simulate failure on connection
   conn.fail(new ActiveMQNotConnectedException());

   // Wait to be informed of failure

   boolean ok = latch.await(1000, TimeUnit.MILLISECONDS);

   Assert.assertTrue(ok);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
protected final ActiveMQSession createSessionInternal(final boolean isXA,
                                                      final boolean transacted,
                                                      int acknowledgeMode,
                                                      final int type) throws JMSException {
   if (transacted) {
      acknowledgeMode = Session.SESSION_TRANSACTED;
   }

   try {
      ClientSession session;
      boolean isBlockOnAcknowledge = sessionFactory.getServerLocator().isBlockOnAcknowledge();
      int ackBatchSize = sessionFactory.getServerLocator().getAckBatchSize();
      if (acknowledgeMode == Session.SESSION_TRANSACTED) {
         session = sessionFactory.createSession(username, password, isXA, false, false, sessionFactory.getServerLocator().isPreAcknowledge(), transactionBatchSize);
      } else if (acknowledgeMode == Session.AUTO_ACKNOWLEDGE) {
         session = sessionFactory.createSession(username, password, isXA, true, true, sessionFactory.getServerLocator().isPreAcknowledge(), 0);
      } else if (acknowledgeMode == Session.DUPS_OK_ACKNOWLEDGE) {
         session = sessionFactory.createSession(username, password, isXA, true, true, sessionFactory.getServerLocator().isPreAcknowledge(), dupsOKBatchSize);
      } else if (acknowledgeMode == Session.CLIENT_ACKNOWLEDGE) {
         session = sessionFactory.createSession(username, password, isXA, true, false, sessionFactory.getServerLocator().isPreAcknowledge(), isBlockOnAcknowledge ? transactionBatchSize : ackBatchSize);
      } else if (acknowledgeMode == ActiveMQJMSConstants.INDIVIDUAL_ACKNOWLEDGE) {
         session = sessionFactory.createSession(username, password, isXA, true, false, false, isBlockOnAcknowledge ? transactionBatchSize : ackBatchSize);
      } else if (acknowledgeMode == ActiveMQJMSConstants.PRE_ACKNOWLEDGE) {
         session = sessionFactory.createSession(username, password, isXA, true, false, true, transactionBatchSize);
      } else {
         throw new JMSRuntimeException("Invalid ackmode: " + acknowledgeMode);
      }

      justCreated = false;

      // Setting multiple times on different sessions doesn't matter since RemotingConnection
      // maintains
      // a set (no duplicates)
      session.addFailureListener(listener);
      session.addFailoverListener(failoverListener);

      ActiveMQSession jbs = createAMQSession(isXA, transacted, acknowledgeMode, session, type);

      sessions.add(jbs);

      if (started) {
         session.start();
      }

      this.addSessionMetaData(session);

      return jbs;
   } catch (ActiveMQException e) {
      throw JMSExceptionHelper.convertFromActiveMQException(e);
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test(timeout = 120000)
public void testBackupServerNotRemoved() throws Exception {
   // HORNETQ-720 Disabling test for replicating backups.
   if (!(backupServer.getServer().getHAPolicy() instanceof SharedStoreSlavePolicy)) {
      return;
   }
   locator.setFailoverOnInitialConnection(true);
   createSessionFactory();

   ClientSession session = sendAndConsume(sf, true);
   CountDownSessionFailureListener listener = new CountDownSessionFailureListener(session);

   session.addFailureListener(listener);

   backupServer.stop();

   liveServer.crash();

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

   backupServer.start();

   Assert.assertTrue("session failure listener", listener.getLatch().await(5, TimeUnit.SECONDS));

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

   ClientMessage message = session.createMessage(true);

   setBody(0, message);

   producer.send(message);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test(timeout = 120000)
public void testLiveAndBackupLiveComesBack() throws Exception {
   locator.setFailoverOnInitialConnection(true);
   createSessionFactory();
   final CountDownLatch latch = new CountDownLatch(1);

   ClientSession session = sendAndConsume(sf, true);

   session.addFailureListener(new CountDownSessionFailureListener(latch, session));

   backupServer.stop();

   liveServer.crash();

   beforeRestart(liveServer);

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

   liveServer.start();

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

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

   ClientMessage message = session.createMessage(true);

   setBody(0, message);

   producer.send(message);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testNoFailureWithPinging() throws Exception {
   ServerLocator locator = createNettyNonHALocator();

   locator.setClientFailureCheckPeriod(PingTest.CLIENT_FAILURE_CHECK_PERIOD);
   locator.setConnectionTTL(PingTest.CLIENT_FAILURE_CHECK_PERIOD * 2);

   ClientSessionFactory csf = createSessionFactory(locator);

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

   PingTest.log.info("Created session");

   Assert.assertEquals(1, ((ClientSessionFactoryInternal) csf).numConnections());

   Listener clientListener = new Listener();

   session.addFailureListener(clientListener);

   RemotingConnection serverConn = null;
   while (serverConn == null) {
      Set<RemotingConnection> conns = server.getRemotingService().getConnections();

      if (!conns.isEmpty()) {
         serverConn = server.getRemotingService().getConnections().iterator().next();
      } else {
         // It's async so need to wait a while
         Thread.sleep(10);
      }
   }

   Listener serverListener = new Listener();

   serverConn.addFailureListener(serverListener);

   Thread.sleep(PingTest.CLIENT_FAILURE_CHECK_PERIOD * 10);

   Assert.assertNull(clientListener.getException());

   Assert.assertNull(serverListener.getException());

   RemotingConnection serverConn2 = server.getRemotingService().getConnections().iterator().next();

   PingTest.log.info("Server conn2 is " + serverConn2);

   Assert.assertTrue(serverConn == serverConn2);

   session.close();

   csf.close();

   locator.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testNoFailureNoPinging() throws Exception {
   TransportConfiguration transportConfig = new TransportConfiguration(INVM_CONNECTOR_FACTORY);
   ServerLocator locator = addServerLocator(ActiveMQClient.createServerLocatorWithoutHA(transportConfig));
   locator.setClientFailureCheckPeriod(-1);
   locator.setConnectionTTL(-1);
   ClientSessionFactory csf = createSessionFactory(locator);

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

   Assert.assertEquals(1, ((ClientSessionFactoryInternal) csf).numConnections());

   Listener clientListener = new Listener();

   session.addFailureListener(clientListener);

   RemotingConnection serverConn = null;
   while (serverConn == null) {
      Set<RemotingConnection> conns = server.getRemotingService().getConnections();

      if (!conns.isEmpty()) {
         serverConn = server.getRemotingService().getConnections().iterator().next();
      } else {
         // It's async so need to wait a while
         Thread.sleep(10);
      }
   }

   Listener serverListener = new Listener();

   serverConn.addFailureListener(serverListener);

   Thread.sleep(ActiveMQClient.DEFAULT_CLIENT_FAILURE_CHECK_PERIOD);

   Assert.assertNull(clientListener.getException());

   Assert.assertNull(serverListener.getException());

   RemotingConnection serverConn2 = server.getRemotingService().getConnections().iterator().next();

   PingTest.log.info("Serverconn2 is " + serverConn2);

   Assert.assertTrue(serverConn == serverConn2);

   session.close();

   csf.close();

   locator.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testAutoFailback() throws Exception {
   ((SharedStoreSlavePolicy) backupServer.getServer().getHAPolicy()).setRestartBackup(false);
   createSessionFactory();
   final CountDownLatch latch = new CountDownLatch(1);

   ClientSession session = sendAndConsume(sf, true);

   CountDownSessionFailureListener listener = new CountDownSessionFailureListener(latch, session);

   session.addFailureListener(listener);

   liveServer.crash();

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

   log.info("backup (nowLive) topology = " + backupServer.getServer().getClusterManager().getDefaultConnection(null).getTopology().describe());

   log.info("Server Crash!!!");

   ClientProducer producer = session.createProducer(ADDRESS);

   ClientMessage message = session.createMessage(true);

   setBody(0, message);

   producer.send(message);

   verifyMessageOnServer(1, 1);

   session.removeFailureListener(listener);

   final CountDownLatch latch2 = new CountDownLatch(1);

   listener = new CountDownSessionFailureListener(latch2, session);

   session.addFailureListener(listener);

   log.info("******* starting live server back");
   liveServer.start();

   Thread.sleep(1000);

   System.out.println("After failback: " + locator.getTopology().describe());

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

   message = session.createMessage(true);

   setBody(1, message);

   producer.send(message);

   session.close();

   verifyMessageOnServer(0, 1);

   wrapUpSessionFactory();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testAutoFailbackThenFailover() throws Exception {
   createSessionFactory();
   ClientSession session = sendAndConsume(sf, true);

   CountDownSessionFailureListener listener = new CountDownSessionFailureListener(session);

   session.addFailureListener(listener);

   IntegrationTestLogger.LOGGER.info("Crashing live server...");

   liveServer.crash(session);

   ClientProducer producer = session.createProducer(ADDRESS);

   ClientMessage message = session.createMessage(true);

   setBody(0, message);

   producer.send(message);

   session.removeFailureListener(listener);

   listener = new CountDownSessionFailureListener(session);

   session.addFailureListener(listener);
   log.info("restarting live node now");
   liveServer.start();

   assertTrue("expected a session failure 1", listener.getLatch().await(5, TimeUnit.SECONDS));

   message = session.createMessage(true);

   setBody(1, message);

   producer.send(message);

   session.removeFailureListener(listener);

   listener = new CountDownSessionFailureListener(session);

   session.addFailureListener(listener);

   waitForBackup(sf, 10);

   IntegrationTestLogger.LOGGER.info("Crashing live server again...");

   liveServer.crash();

   assertTrue("expected a session failure 2", listener.getLatch().await(5, TimeUnit.SECONDS));

   session.close();

   wrapUpSessionFactory();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test(timeout = 120000)
public void testLiveAndBackupLiveComesBackNewFactory() throws Exception {
   locator.setFailoverOnInitialConnection(true);
   createSessionFactory();

   final CountDownLatch latch = new CountDownLatch(1);

   ClientSession session = sendAndConsume(sf, true);

   session.addFailureListener(new CountDownSessionFailureListener(latch, session));

   backupServer.stop();

   liveServer.crash();

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

   liveServer.start();

   Assert.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();

   createClientSessionFactory();

   session = createSession(sf);

   ClientConsumer cc = session.createConsumer(FailoverTestBase.ADDRESS);

   session.start();

   ClientMessage cm = cc.receive(5000);

   Assert.assertNotNull(cm);

   Assert.assertEquals("message0", cm.getBodyBuffer().readString());
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test(timeout = 120000)
public void testLiveAndBackupBackupComesBackNewFactory() throws Exception {
   locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setFailoverOnInitialConnection(true).setReconnectAttempts(300).setRetryInterval(100);

   sf = createSessionFactoryAndWaitForTopology(locator, 2);

   ClientSession session = sendAndConsume(sf, true);

   CountDownSessionFailureListener listener = new CountDownSessionFailureListener(session);

   session.addFailureListener(listener);

   backupServer.stop();

   liveServer.crash();

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

   if (!backupServer.getServer().getHAPolicy().isSharedStore()) {
      // XXX
      // this test would not make sense in the remote replication use case, without the following
      backupServer.getServer().setHAPolicy(new SharedStoreMasterPolicy());
   }

   backupServer.start();

   Assert.assertTrue("session failure listener", listener.getLatch().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();

   createClientSessionFactory();

   session = createSession(sf);

   ClientConsumer cc = session.createConsumer(FailoverTestBase.ADDRESS);

   session.start();

   ClientMessage cm = cc.receive(5000);

   Assert.assertNotNull(cm);

   Assert.assertEquals("message0", cm.getBodyBuffer().readString());
}