@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);
  }
Esempio n. 3
0
 /**
  * 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);
   }
 }
Esempio n. 4
0
  @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
          }
        }
      }
    }
  }
Esempio n. 6
0
 protected void crash(final boolean waitFailure, final ClientSession... sessions)
     throws Exception {
   liveServer.crash(waitFailure, sessions);
 }
Esempio n. 7
0
 protected void crash(final ClientSession... sessions) throws Exception {
   liveServer.crash(sessions);
 }