@Test
public void testStartBackupFirst() throws Exception {
for (TestableServer backupServer : backupServers) {
backupServer.start();
}
for (TestableServer liveServer : liveServers) {
liveServer.start();
}
waitForTopology(liveServers.get(0).getServer(), liveServers.size(), liveServers.size());
sendCrashReceive();
}
/**
* @param node The node which we should fail
* @param originalLiveNode The number of the original node, to locate session to fail
* @throws Exception
*/
protected void failNode(final int node, final int originalLiveNode) throws Exception {
ClusterWithBackupFailoverTestBase.log.info("*** failing node " + node);
HornetQServer server = getServer(node);
TestableServer tstServer = new SameProcessHornetQServer(server);
ClientSession[] sessionsArray = exploreSessions(originalLiveNode);
tstServer.crash(sessionsArray);
}
/**
* Waits for backup to be in the "started" state and to finish synchronization with its live.
*
* @param sessionFactory
* @param seconds
* @throws Exception
*/
protected void waitForBackup(ClientSessionFactoryInternal sessionFactory, int seconds)
throws Exception {
final HornetQServerImpl actualServer = (HornetQServerImpl) backupServer.getServer();
if (actualServer.getConfiguration().isSharedStore()) {
waitForServer(actualServer);
} else {
waitForRemoteBackup(sessionFactory, seconds, true, actualServer);
}
}
@Override
protected void setUp() throws Exception {
super.setUp();
clearData();
createConfigs();
liveServer.setIdentity(this.getClass().getSimpleName() + "/liveServer");
liveServer.start();
waitForServer(liveServer.getServer());
if (backupServer != null) {
backupServer.setIdentity(this.getClass().getSimpleName() + "/backupServer");
if (startBackupServer) {
backupServer.start();
waitForServer(backupServer.getServer());
}
}
}
protected void sendCrashReceive() throws Exception {
ServerLocator[] locators = new ServerLocator[liveServers.size()];
try {
for (int i = 0; i < locators.length; i++) {
locators[i] = getServerLocator(i);
}
ClientSessionFactory[] factories = new ClientSessionFactory[liveServers.size()];
for (int i = 0; i < factories.length; i++) {
factories[i] = createSessionFactory(locators[i]);
}
ClientSession[] sessions = new ClientSession[liveServers.size()];
for (int i = 0; i < factories.length; i++) {
sessions[i] = createSession(factories[i], true, true);
sessions[i].createQueue(
MultipleServerFailoverTestBase.ADDRESS,
MultipleServerFailoverTestBase.ADDRESS,
null,
true);
}
// make sure bindings are ready before sending messages
for (int i = 0; i < liveServers.size(); i++) {
this.waitForBindings(liveServers.get(i).getServer(), ADDRESS.toString(), true, 1, 0, 2000);
this.waitForBindings(liveServers.get(i).getServer(), ADDRESS.toString(), false, 1, 0, 2000);
}
ClientProducer producer = sessions[0].createProducer(MultipleServerFailoverTestBase.ADDRESS);
for (int i = 0; i < liveServers.size() * 100; i++) {
ClientMessage message = sessions[0].createMessage(true);
setBody(i, message);
message.putIntProperty("counter", i);
producer.send(message);
}
producer.close();
for (TestableServer liveServer : liveServers) {
waitForDistribution(MultipleServerFailoverTestBase.ADDRESS, liveServer.getServer(), 100);
}
for (TestableServer liveServer : liveServers) {
liveServer.crash();
}
ClientConsumer[] consumers = new ClientConsumer[liveServers.size()];
for (int i = 0; i < factories.length; i++) {
consumers[i] = sessions[i].createConsumer(MultipleServerFailoverTestBase.ADDRESS);
sessions[i].start();
}
for (int i = 0; i < 100; i++) {
for (ClientConsumer consumer : consumers) {
ClientMessage message = consumer.receive(1000);
Assert.assertNotNull("expecting durable msg " + i, message);
message.acknowledge();
}
}
} finally {
for (ServerLocator locator : locators) {
if (locator != null) {
try {
locator.close();
} catch (Exception e) {
// ignore
}
}
}
}
}
protected void crash(final boolean waitFailure, final ClientSession... sessions)
throws Exception {
liveServer.crash(waitFailure, sessions);
}
protected void crash(final ClientSession... sessions) throws Exception {
liveServer.crash(sessions);
}
