@Test
public void testAutoFailbackThenFailover() throws Exception {
createSessionFactory();
ClientSession session = sendAndConsume(sf, true);
CountDownSessionFailureListener listener = new CountDownSessionFailureListener();
session.addFailureListener(listener);
liveServer.crash(session);
ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
ClientMessage message = session.createMessage(true);
setBody(0, message);
producer.send(message);
session.removeFailureListener(listener);
listener = new CountDownSessionFailureListener();
session.addFailureListener(listener);
log.info("restarting live node now");
liveServer.start();
assertTrue("expected a session failure", listener.getLatch().await(5, TimeUnit.SECONDS));
message = session.createMessage(true);
setBody(1, message);
producer.send(message);
session.removeFailureListener(listener);
listener = new CountDownSessionFailureListener();
session.addFailureListener(listener);
waitForBackup(sf, 10);
liveServer.crash();
assertTrue("expected a session failure", listener.getLatch().await(5, TimeUnit.SECONDS));
session.close();
wrapUpSessionFactory();
}
/**
* Basic fail-back test.
*
* @throws Exception
*/
@Test
public void testFailBack() throws Exception {
createSessionFactory();
ClientSession session = sendAndConsume(sf, true);
ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
sendMessages(session, producer, NUM_MESSAGES);
session.commit();
crash(session);
session.start();
ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
receiveMessages(consumer, 0, NUM_MESSAGES, true);
producer = session.createProducer(FailoverTestBase.ADDRESS);
sendMessages(session, producer, 2 * NUM_MESSAGES);
session.commit();
assertFalse("must NOT be a backup", liveServer.getServer().getConfiguration().isBackup());
adaptLiveConfigForReplicatedFailBack(liveServer.getServer().getConfiguration());
CountDownSessionFailureListener listener = new CountDownSessionFailureListener();
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);
}
/**
* Connects to the yamcs server. This method blocks until a connection is established or some
* error has occurred, thus this should be called in a separate thread. Hornetq will try
* indefinitely to establish the connection and also provides automatic re-connection afterwards.
*
* @throws Exception if the hornetq session could not be established due to some error
*/
public void connect() throws Exception {
for (ConnectionListener cl : connectionListeners) {
cl.connecting(connParams.getUrl());
}
Map<String, Object> tcpConfig = new HashMap<String, Object>();
tcpConfig.put(TransportConstants.HOST_PROP_NAME, connParams.host);
tcpConfig.put(TransportConstants.PORT_PROP_NAME, connParams.port);
locator =
HornetQClient.createServerLocatorWithoutHA(
new TransportConfiguration(NettyConnectorFactory.class.getName(), tcpConfig));
locator.setInitialConnectAttempts(initialConnectAttempts);
locator.setReconnectAttempts(reconnectAttempts);
locator.setRetryInterval(retryInterval);
locator.setRetryIntervalMultiplier(retryIntervalMultiplier);
locator.setMaxRetryInterval(maxRetryInterval);
locator.setAckBatchSize(ackBatchSize);
sessionFactory = locator.createSessionFactory();
// TODO Use hornetq auth (like YamcsConnector), or keep anonymous connection?
session = sessionFactory.createSession(false, true, true, preAcknowledge);
session.addFailureListener(YamcsAckConnector.this);
session.start();
for (ConnectionListener cl : connectionListeners) {
cl.connected(connParams.getUrl());
}
}
@Test
public void testAutoFailback() throws Exception {
createSessionFactory();
final CountDownLatch latch = new CountDownLatch(1);
ClientSession session = sendAndConsume(sf, true);
CountDownSessionFailureListener listener = new CountDownSessionFailureListener(latch);
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(FailoverTestBase.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.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();
}
