@Test
 public void testBasicSend2times() throws Exception {
   SimpleString dla = new SimpleString("DLA");
   SimpleString qName = new SimpleString("q1");
   AddressSettings addressSettings =
       new AddressSettings().setMaxDeliveryAttempts(2).setDeadLetterAddress(dla);
   server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
   SimpleString dlq = new SimpleString("DLQ1");
   clientSession.createQueue(dla, dlq, null, false);
   clientSession.createQueue(qName, qName, null, false);
   ClientProducer producer = clientSession.createProducer(qName);
   producer.send(createTextMessage(clientSession, "heyho!"));
   clientSession.start();
   ClientConsumer clientConsumer = clientSession.createConsumer(qName);
   ClientMessage m = clientConsumer.receive(5000);
   m.acknowledge();
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   // force a cancel
   clientSession.rollback();
   clientSession.start();
   m = clientConsumer.receive(5000);
   m.acknowledge();
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   // force a cancel
   clientSession.rollback();
   m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();
   clientConsumer = clientSession.createConsumer(dlq);
   m = clientConsumer.receive(5000);
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
 }
  @Test
  public void testDeadLetterAddressWithOverridenSublevelAddressSettings() throws Exception {
    int defaultDeliveryAttempt = 3;
    int specificeDeliveryAttempt = defaultDeliveryAttempt + 1;

    SimpleString address = new SimpleString("prefix.address");
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString defaultDeadLetterAddress = RandomUtil.randomSimpleString();
    SimpleString defaultDeadLetterQueue = RandomUtil.randomSimpleString();
    SimpleString specificDeadLetterAddress = RandomUtil.randomSimpleString();
    SimpleString specificDeadLetterQueue = RandomUtil.randomSimpleString();

    AddressSettings defaultAddressSettings =
        new AddressSettings()
            .setMaxDeliveryAttempts(defaultDeliveryAttempt)
            .setDeadLetterAddress(defaultDeadLetterAddress);
    server.getAddressSettingsRepository().addMatch("*", defaultAddressSettings);
    AddressSettings specificAddressSettings =
        new AddressSettings()
            .setMaxDeliveryAttempts(specificeDeliveryAttempt)
            .setDeadLetterAddress(specificDeadLetterAddress);
    server.getAddressSettingsRepository().addMatch(address.toString(), specificAddressSettings);

    clientSession.createQueue(address, queue, false);
    clientSession.createQueue(defaultDeadLetterAddress, defaultDeadLetterQueue, false);
    clientSession.createQueue(specificDeadLetterAddress, specificDeadLetterQueue, false);

    ClientProducer producer = clientSession.createProducer(address);
    ClientMessage clientMessage = createTextMessage(clientSession, "heyho!");
    producer.send(clientMessage);

    clientSession.start();
    ClientConsumer clientConsumer = clientSession.createConsumer(queue);
    ClientConsumer defaultDeadLetterConsumer = clientSession.createConsumer(defaultDeadLetterQueue);
    ClientConsumer specificDeadLetterConsumer =
        clientSession.createConsumer(specificDeadLetterQueue);

    for (int i = 0; i < defaultDeliveryAttempt; i++) {
      ClientMessage m = clientConsumer.receive(500);
      Assert.assertNotNull(m);
      Assert.assertEquals(i + 1, m.getDeliveryCount());
      m.acknowledge();
      clientSession.rollback();
    }

    Assert.assertNull(defaultDeadLetterConsumer.receiveImmediate());
    Assert.assertNull(specificDeadLetterConsumer.receiveImmediate());

    // one more redelivery attempt:
    ClientMessage m = clientConsumer.receive(500);
    Assert.assertNotNull(m);
    Assert.assertEquals(specificeDeliveryAttempt, m.getDeliveryCount());
    m.acknowledge();
    clientSession.rollback();

    Assert.assertNull(defaultDeadLetterConsumer.receiveImmediate());
    Assert.assertNotNull(specificDeadLetterConsumer.receive(500));
  }
  @Test
  public void testStopStartMultipleConsumers() throws Exception {
    locator.setConsumerWindowSize(getMessageEncodeSize(QUEUE) * 33);
    ClientSessionFactory sf = createSessionFactory(locator);

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

    session.createQueue(QUEUE, QUEUE, null, false);

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 100;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      message.putIntProperty(new SimpleString("i"), i);
      producer.send(message);
    }

    ClientConsumer consumer = session.createConsumer(QUEUE);
    ClientConsumer consumer2 = session.createConsumer(QUEUE);
    ClientConsumer consumer3 = session.createConsumer(QUEUE);

    session.start();

    ClientMessage cm = consumer.receive(5000);
    Assert.assertNotNull(cm);
    cm.acknowledge();
    cm = consumer2.receive(5000);
    Assert.assertNotNull(cm);
    cm.acknowledge();
    cm = consumer3.receive(5000);
    Assert.assertNotNull(cm);
    cm.acknowledge();

    session.stop();
    cm = consumer.receiveImmediate();
    Assert.assertNull(cm);
    cm = consumer2.receiveImmediate();
    Assert.assertNull(cm);
    cm = consumer3.receiveImmediate();
    Assert.assertNull(cm);

    session.start();
    cm = consumer.receive(5000);
    Assert.assertNotNull(cm);
    cm = consumer2.receive(5000);
    Assert.assertNotNull(cm);
    cm = consumer3.receive(5000);
    Assert.assertNotNull(cm);
    session.close();
  }
  @Test
  public void testConsumerBrowserMessageAckDoesNothing() throws Exception {
    ClientSessionFactory sf = createSessionFactory(locator);

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

    session.createQueue(QUEUE, QUEUE, null, false);

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 100;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      producer.send(message);
    }

    ClientConsumer consumer = session.createConsumer(QUEUE, null, true);

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

      message2.acknowledge();

      Assert.assertEquals("m" + i, message2.getBodyBuffer().readString());
    }
    // assert that all the messages are there and none have been acked
    Assert.assertEquals(
        0, ((Queue) server.getPostOffice().getBinding(QUEUE).getBindable()).getDeliveringCount());
    Assert.assertEquals(
        100, getMessageCount(((Queue) server.getPostOffice().getBinding(QUEUE).getBindable())));

    session.close();
  }
  protected static ClientMessage[] consumeMessages(
      final int expected, final ClientConsumer consumer) throws Exception {
    ClientMessage[] messages = new ClientMessage[expected];

    ClientMessage m = null;
    for (int i = 0; i < expected; i++) {
      m = consumer.receive(500);
      if (m != null) {
        for (SimpleString key : m.getPropertyNames()) {
          System.out.println(key + "=" + m.getObjectProperty(key));
        }
      }
      Assert.assertNotNull("expected to received " + expected + " messages, got only " + i, m);
      messages[i] = m;
      m.acknowledge();
    }
    m = consumer.receiveImmediate();
    if (m != null) {
      for (SimpleString key : m.getPropertyNames()) {
        System.out.println(key + "=" + m.getObjectProperty(key));
      }
    }
    Assert.assertNull("received one more message than expected (" + expected + ")", m);

    return messages;
  }
Ejemplo n.º 6
0
  @Test
  public void testRestartJournal() throws Throwable {
    runExternalProcess(getTestDir(), 0, JournalCrashTest.FIRST_RUN);
    runExternalProcess(getTestDir(), JournalCrashTest.FIRST_RUN, JournalCrashTest.SECOND_RUN);
    runExternalProcess(getTestDir(), JournalCrashTest.SECOND_RUN, JournalCrashTest.THIRD_RUN);
    runExternalProcess(getTestDir(), JournalCrashTest.THIRD_RUN, JournalCrashTest.FOURTH_RUN);

    printJournal();

    startServer();

    try (ClientSession session = factory.createSession(true, true)) {

      ClientConsumer consumer = session.createConsumer(QUEUE);
      session.start();

      for (int i = 0; i < JournalCrashTest.FOURTH_RUN; i++) {
        ClientMessage msg = consumer.receive(5000);

        Assert.assertNotNull("Msg at " + i, msg);

        msg.acknowledge();

        Assert.assertEquals(i, msg.getObjectProperty(new SimpleString("key")));
      }
      session.close();
    }
  }
      @Override
      public void onMessage(final ClientMessage message) {

        try {
          if (!started) {
            failed = true;
          }

          messageReceived++;

          log.info("got message " + messageReceived);

          latch.countDown();

          if (latch.getCount() == 0) {
            message.acknowledge();

            started = false;

            consumer.setMessageHandler(null);
          }

        } catch (Exception e) {
        }
      }
      @Override
      public void onMessage(final ClientMessage message) {
        try {
          Thread.sleep(10);

          message.acknowledge();
        } catch (Exception e) {
        }
      }
  @Test
  public void testStopStartConsumerSyncReceive() throws Exception {
    ClientSessionFactory sf = createSessionFactory(locator);

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

    session.createQueue(QUEUE, QUEUE, null, false);

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 100;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      message.putIntProperty(new SimpleString("i"), i);
      producer.send(message);
    }

    final ClientConsumer consumer = session.createConsumer(QUEUE);

    session.start();

    for (int i = 0; i < numMessages / 2; i++) {
      ClientMessage cm = consumer.receive(5000);
      Assert.assertNotNull(cm);
      cm.acknowledge();
    }
    session.stop();
    long time = System.currentTimeMillis();
    ClientMessage cm = consumer.receive(1000);
    long taken = System.currentTimeMillis() - time;
    Assert.assertTrue(taken >= 1000);
    Assert.assertNull(cm);

    session.start();
    for (int i = 0; i < numMessages / 2; i++) {
      cm = consumer.receive(5000);
      Assert.assertNotNull(cm);
      cm.acknowledge();
    }

    session.close();
  }
 public void onMessage(final ClientMessage message) {
   list.add(message);
   if (acknowledge) {
     try {
       message.acknowledge();
     } catch (ActiveMQException e) {
       // ignore
     }
   }
   latch.countDown();
 }
 /**
  * @param consumer
  * @throws Exception
  */
 private void readConsumer(String consumerName, ClientConsumer consumer) throws Exception {
   ClientMessage message = consumer.receive(5000);
   assertNotNull(message);
   System.out.println(
       "consumer = "
           + consumerName
           + " message, color="
           + message.getStringProperty("color")
           + ", msg = "
           + message.getStringProperty("value"));
   message.acknowledge();
 }
  @Test
  public void testPartialQueue() throws Exception {
    ClientSession session = basicSetUp();

    session.createQueue("myAddress", "myQueue1", true);
    session.createQueue("myAddress", "myQueue2", true);

    ClientProducer producer = session.createProducer("myAddress");

    ClientMessage msg = session.createMessage(true);
    producer.send(msg);

    ClientConsumer consumer = session.createConsumer("myQueue1");
    session.start();
    msg = consumer.receive(CONSUMER_TIMEOUT);
    assertNotNull(msg);
    msg.acknowledge();
    consumer.close();

    session.close();
    locator.close();
    server.stop();

    ByteArrayOutputStream xmlOutputStream = new ByteArrayOutputStream();
    XmlDataExporter xmlDataExporter = new XmlDataExporter();
    xmlDataExporter.process(
        xmlOutputStream,
        server.getConfiguration().getBindingsDirectory(),
        server.getConfiguration().getJournalDirectory(),
        server.getConfiguration().getPagingDirectory(),
        server.getConfiguration().getLargeMessagesDirectory());
    System.out.print(new String(xmlOutputStream.toByteArray()));

    clearDataRecreateServerDirs();
    server.start();
    locator = createInVMNonHALocator();
    factory = createSessionFactory(locator);
    session = factory.createSession(false, true, true);

    ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
    XmlDataImporter xmlDataImporter = new XmlDataImporter();
    xmlDataImporter.process(xmlInputStream, session);
    consumer = session.createConsumer("myQueue1");
    session.start();
    msg = consumer.receive(CONSUMER_TIMEOUT);
    assertNull(msg);
    consumer.close();

    consumer = session.createConsumer("myQueue2");
    msg = consumer.receive(CONSUMER_TIMEOUT);
    assertNotNull(msg);
  }
  @Test
  public void testLoad() throws Throwable {
    ActiveMQServer server2 = createServer(true, false);

    server2.getConfiguration().setJournalFileSize(10 * 1024 * 1024);
    server2.getConfiguration().setJournalMinFiles(10);
    server2.getConfiguration().setJournalCompactMinFiles(3);
    server2.getConfiguration().setJournalCompactPercentage(50);

    for (int i = 0; i < 10; i++) {
      server2.start();

      ServerLocator locator =
          createInVMNonHALocator().setMinLargeMessageSize(1024 * 1024).setBlockOnDurableSend(false);

      ClientSessionFactory sf = createSessionFactory(locator);

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

      try {
        session.createQueue("slow-queue", "slow-queue");
      } catch (Exception ignored) {
      }

      session.start();
      ClientConsumer consumer = session.createConsumer("slow-queue");

      while (true) {
        System.out.println("Received message from previous");
        ClientMessage msg = consumer.receiveImmediate();
        if (msg == null) {
          break;
        }
        msg.acknowledge();
      }

      session.close();

      produceMessages(sf, 30000);

      server2.stop();
    }
  }
  @Test
  public void testLargeMessageFileLeak() throws Exception {
    OperatingSystemMXBean os = ManagementFactory.getOperatingSystemMXBean();

    // only run this on *nix systems which will have the
    // com.sun.management.UnixOperatingSystemMXBean (needed to check open file count)
    Assume.assumeTrue(os instanceof UnixOperatingSystemMXBean);

    long fdBaseline = ((UnixOperatingSystemMXBean) os).getOpenFileDescriptorCount();
    final int SIZE = 2 * 1024;
    SimpleString dla = new SimpleString("DLA");
    SimpleString qName = new SimpleString("q1");
    SimpleString adName = new SimpleString("ad1");

    AddressSettings addressSettings =
        new AddressSettings().setMaxDeliveryAttempts(1).setDeadLetterAddress(dla);
    server.getAddressSettingsRepository().addMatch(adName.toString(), addressSettings);
    SimpleString dlq = new SimpleString("DLQ1");
    clientSession.createQueue(dla, dlq, null, false);
    clientSession.createQueue(adName, qName, null, false);
    for (int i = 0; i < 10; i++) {
      ClientProducer producer = clientSession.createProducer(adName);
      ClientMessage clientFile = clientSession.createMessage(true);
      clientFile.setBodyInputStream(ActiveMQTestBase.createFakeLargeStream(SIZE));
      producer.send(clientFile);
      clientSession.start();
      ClientConsumer clientConsumer = clientSession.createConsumer(qName);
      ClientMessage m = clientConsumer.receive(500);
      m.acknowledge();
      Assert.assertNotNull(m);

      // force a cancel
      clientSession.rollback();
      m = clientConsumer.receiveImmediate();
      Assert.assertNull(m);
      clientConsumer.close();
    }
    assertEquals(
        "File descriptors are leaking",
        0,
        ((UnixOperatingSystemMXBean) os).getOpenFileDescriptorCount() - fdBaseline);
  }
      @Override
      public void onMessage(final ClientMessage message) {

        try {
          if (!started) {
            failed = true;
          }
          messageReceived++;
          latch.countDown();

          if (stop && latch.getCount() == 0) {

            message.acknowledge();
            session.stop();
            started = false;
          }

        } catch (Exception e) {
        }
      }
      @Override
      public void onMessage(final ClientMessage message) {

        try {
          if (!started) {
            failed = true;
          }

          count++;

          if (count == 10) {
            message.acknowledge();
            session.stop();
            started = false;
          }

          latch.countDown();
        } catch (Exception e) {
        }
      }
  @Test
  public void testDeadlLetterAddressWithDefaultAddressSettings() throws Exception {
    int deliveryAttempt = 3;

    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString deadLetterAddress = RandomUtil.randomSimpleString();
    SimpleString deadLetterQueue = RandomUtil.randomSimpleString();
    AddressSettings addressSettings =
        new AddressSettings()
            .setMaxDeliveryAttempts(deliveryAttempt)
            .setDeadLetterAddress(deadLetterAddress);
    server.getAddressSettingsRepository().setDefault(addressSettings);

    clientSession.createQueue(address, queue, false);
    clientSession.createQueue(deadLetterAddress, deadLetterQueue, false);

    ClientProducer producer = clientSession.createProducer(address);
    ClientMessage clientMessage = createTextMessage(clientSession, "heyho!");
    producer.send(clientMessage);

    clientSession.start();
    ClientConsumer clientConsumer = clientSession.createConsumer(queue);
    for (int i = 0; i < deliveryAttempt; i++) {
      ClientMessage m = clientConsumer.receive(500);
      Assert.assertNotNull(m);
      DeadLetterAddressTest.log.info("i is " + i);
      DeadLetterAddressTest.log.info("delivery cout is " + m.getDeliveryCount());
      Assert.assertEquals(i + 1, m.getDeliveryCount());
      m.acknowledge();
      clientSession.rollback();
    }
    ClientMessage m = clientConsumer.receive(500);
    Assert.assertNull("not expecting a message", m);
    clientConsumer.close();

    clientConsumer = clientSession.createConsumer(deadLetterQueue);
    m = clientConsumer.receive(500);
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
  }
  private ClientSession sendAndConsume(final ClientSessionFactory sf, final boolean createQueue)
      throws Exception {
    ClientSession session = sf.createSession(false, true, true);

    if (createQueue) {
      session.createQueue(ADDRESS, ADDRESS, null, false);
    }

    ClientProducer producer = session.createProducer(ADDRESS);

    final int numMessages = 1000;

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

    ClientConsumer consumer = session.createConsumer(ADDRESS);

    session.start();

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

      assertEquals("aardvarks", message2.getBodyBuffer().readString());

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

      message2.acknowledge();
    }

    ClientMessage message3 = consumer.receiveImmediate();

    assertNull(message3);

    return session;
  }
  private ClientMessage receiveMessage() throws Exception {
    final ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(null, null, false, true, true, false, 0);

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

    ClientMessage message = consumer.receive(1000);

    session.commit();

    if (message != null) {
      message.acknowledge();
    }

    consumer.close();

    session.close();

    return message;
  }
    @Override
    public void run() {
      ClientSession session = null;
      latchReady.countDown();
      try {
        ActiveMQTestBase.waitForLatch(latchStart);
        session = sf.createSession(false, false);
        session.start();
        ClientConsumer cons = session.createConsumer(QUEUE);
        for (int i = 0; i < numberOfMessages; i++) {
          ClientMessage msg = cons.receive(60 * 1000);
          msg.acknowledge();
          if (i % commitInterval == 0) {
            session.commit();
          }
          if (i % 1000 == 0) {
            // System.out.println(Thread.currentThread().getName() + "::sent #" + i);
          }
        }

        System.out.println(
            "Thread "
                + Thread.currentThread().getName()
                + " received "
                + numberOfMessages
                + " messages");

        session.commit();
      } catch (Throwable e) {
        this.e = e;
      } finally {
        try {
          session.close();
        } catch (Throwable e) {
          this.e = e;
        }
      }
    }
    public void receiveMessages(String queueName, int num, boolean checkDup)
        throws ActiveMQException {
      ClientSession session = sessionFactory.createSession();
      session.start();
      ClientConsumer consumer = session.createConsumer("jms.queue." + queueName);
      for (int i = 0; i < num; i++) {
        ClientMessage m = consumer.receive(30000);
        assertNotNull("i=" + i, m);
        assertNotNull(m.getStringProperty("bridge-message"));
        m.acknowledge();
      }

      ClientMessage m = consumer.receive(500);
      if (checkDup) {
        assertNull(m);
      } else {
        // drain messages
        while (m != null) {
          m = consumer.receive(200);
        }
      }

      session.close();
    }
  @Test
  public void testDurableNonDurable() throws Exception {
    final String testAddress = "testAddress";

    final String queueName1 = "queue1";

    final String queueName2 = "queue2";

    CoreQueueConfiguration queue1 =
        new CoreQueueConfiguration().setAddress(testAddress).setName(queueName1).setDurable(false);

    CoreQueueConfiguration queue2 =
        new CoreQueueConfiguration().setAddress(testAddress).setName(queueName2);

    List<CoreQueueConfiguration> queueConfs = new ArrayList<CoreQueueConfiguration>();

    queueConfs.add(queue1);
    queueConfs.add(queue2);

    configuration.addQueueConfiguration(queue1).addQueueConfiguration(queue2);

    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(configuration));

    server.start();

    ServerLocator locator = createInVMNonHALocator();

    ClientSessionFactory sf = createSessionFactory(locator);

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

    ClientProducer producer = session.createProducer(new SimpleString(testAddress));

    final SimpleString propKey = new SimpleString("testkey");

    final int numMessages = 1;

    PredefinedQueueTest.log.info("sending messages");

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = session.createMessage(true);

      message.putIntProperty(propKey, i);

      producer.send(message);
    }

    session.close();

    PredefinedQueueTest.log.info("stopping");

    sf.close();

    server.stop();

    server.start();

    sf = createSessionFactory(locator);

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

    session.start();

    ClientConsumer consumer1 = session.createConsumer(queueName1);

    ClientConsumer consumer2 = session.createConsumer(queueName2);

    ClientMessage message = consumer1.receiveImmediate();

    Assert.assertNull(message);

    for (int i = 0; i < numMessages; i++) {
      message = consumer2.receive(200);
      Assert.assertNotNull(message);
      Assert.assertEquals(i, message.getObjectProperty(propKey));
      message.acknowledge();
    }

    Assert.assertNull(consumer1.receiveImmediate());
    Assert.assertNull(consumer2.receiveImmediate());
  }
  @Test
  public void testProduceAndConsume() throws Throwable {
    int numberOfConsumers = 5;
    // this test assumes numberOfConsumers == numberOfProducers
    int numberOfProducers = numberOfConsumers;
    int produceMessage = 10000;
    int commitIntervalProduce = 100;
    int consumeMessage = (int) (produceMessage * 0.9);
    int commitIntervalConsume = 100;

    ClientSession session = sf.createSession(false, false);
    session.createQueue("compact", "compact-queue", true);

    ClientProducer producer = session.createProducer("compact");

    for (int i = 0; i < 100; i++) {
      producer.send(session.createMessage(true));
    }

    session.commit();

    // Number of messages expected to be received after restart
    int numberOfMessagesExpected = (produceMessage - consumeMessage) * numberOfConsumers;

    CountDownLatch latchReady = new CountDownLatch(numberOfConsumers + numberOfProducers);

    CountDownLatch latchStart = new CountDownLatch(1);

    ArrayList<BaseThread> threads = new ArrayList<BaseThread>();

    ProducerThread[] prod = new ProducerThread[numberOfProducers];
    for (int i = 0; i < numberOfProducers; i++) {
      prod[i] =
          new ProducerThread(i, latchReady, latchStart, produceMessage, commitIntervalProduce);
      prod[i].start();
      threads.add(prod[i]);
    }

    ConsumerThread[] cons = new ConsumerThread[numberOfConsumers];

    for (int i = 0; i < numberOfConsumers; i++) {
      cons[i] =
          new ConsumerThread(i, latchReady, latchStart, consumeMessage, commitIntervalConsume);
      cons[i].start();
      threads.add(cons[i]);
    }

    ActiveMQTestBase.waitForLatch(latchReady);
    latchStart.countDown();

    for (BaseThread t : threads) {
      t.join();
      if (t.e != null) {
        throw t.e;
      }
    }

    server.stop();

    setupServer(JournalType.NIO);

    ClientSession sess = sf.createSession(true, true);

    ClientConsumer consumer = sess.createConsumer(QUEUE);

    sess.start();

    for (int i = 0; i < numberOfMessagesExpected; i++) {
      ClientMessage msg = consumer.receive(5000);
      Assert.assertNotNull(msg);

      if (i % 1000 == 0) {
        System.out.println("Received #" + i + "  on thread before end");
      }
      msg.acknowledge();
    }

    Assert.assertNull(consumer.receiveImmediate());

    sess.close();
  }
  /** In this method we apply the JMS acknowledgement and redelivery semantics as per JMS spec */
  @Override
  public void onMessage(final ClientMessage message) {
    ActiveMQMessage msg = ActiveMQMessage.createMessage(message, session.getCoreSession());

    if (individualACK) {
      msg.setIndividualAcknowledge();
    }

    try {
      msg.doBeforeReceive();
    } catch (Exception e) {
      ActiveMQJMSClientLogger.LOGGER.errorPreparingMessageForReceipt(
          msg.getCoreMessage().toString(), e);

      return;
    }

    if (transactedOrClientAck) {
      try {
        message.acknowledge();
      } catch (ActiveMQException e) {
        ((ClientSessionInternal) session.getCoreSession()).markRollbackOnly();
        ActiveMQJMSClientLogger.LOGGER.errorProcessingMessage(e);
      }
    }

    try {
      connection.getThreadAwareContext().setCurrentThread(false);
      listener.onMessage(msg);
    } catch (RuntimeException e) {
      // See JMS 1.1 spec, section 4.5.2

      ActiveMQJMSClientLogger.LOGGER.onMessageError(e);

      if (!transactedOrClientAck) {
        try {
          if (individualACK) {
            message.individualAcknowledge();
          }

          session.getCoreSession().rollback(true);

          session.setRecoverCalled(true);
        } catch (Exception e2) {
          ActiveMQJMSClientLogger.LOGGER.errorRecoveringSession(e2);
        }
      }
    } finally {
      connection.getThreadAwareContext().clearCurrentThread(false);
    }
    if (!session.isRecoverCalled() && !individualACK) {
      try {
        // We don't want to call this if the consumer was closed from inside onMessage
        if (!consumer.isClosed() && !transactedOrClientAck) {
          message.acknowledge();
        }
      } catch (ActiveMQException e) {
        ((ClientSessionInternal) session.getCoreSession()).markRollbackOnly();
        ActiveMQJMSClientLogger.LOGGER.errorProcessingMessage(e);
      }
    }

    session.setRecoverCalled(false);
  }
  @Test
  public void testLargeMessage() throws Exception {
    server = createServer(true);
    server.start();
    locator = createInVMNonHALocator();
    factory = createSessionFactory(locator);
    ClientSession session = factory.createSession(false, false);

    LargeServerMessageImpl fileMessage =
        new LargeServerMessageImpl((JournalStorageManager) server.getStorageManager());

    fileMessage.setMessageID(1005);
    fileMessage.setDurable(true);

    for (int i = 0; i < 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE; i++) {
      fileMessage.addBytes(new byte[] {getSamplebyte(i)});
    }

    fileMessage.putLongProperty(
        Message.HDR_LARGE_BODY_SIZE, 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);

    fileMessage.releaseResources();

    session.createQueue("A", "A", true);

    ClientProducer prod = session.createProducer("A");

    prod.send(fileMessage);

    fileMessage.deleteFile();

    session.commit();

    session.close();
    locator.close();
    server.stop();

    ByteArrayOutputStream xmlOutputStream = new ByteArrayOutputStream();
    XmlDataExporter xmlDataExporter = new XmlDataExporter();
    xmlDataExporter.process(
        xmlOutputStream,
        server.getConfiguration().getBindingsDirectory(),
        server.getConfiguration().getJournalDirectory(),
        server.getConfiguration().getPagingDirectory(),
        server.getConfiguration().getLargeMessagesDirectory());
    System.out.print(new String(xmlOutputStream.toByteArray()));

    clearDataRecreateServerDirs();
    server.start();
    locator = createInVMNonHALocator();
    factory = createSessionFactory(locator);
    session = factory.createSession(false, true, true);

    ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
    XmlDataImporter xmlDataImporter = new XmlDataImporter();
    xmlDataImporter.process(xmlInputStream, session);
    session.close();
    session = factory.createSession(false, false);
    session.start();

    ClientConsumer cons = session.createConsumer("A");

    ClientMessage msg = cons.receive(CONSUMER_TIMEOUT);

    assertNotNull(msg);

    assertEquals(2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE, msg.getBodySize());

    for (int i = 0; i < 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE; i++) {
      assertEquals(getSamplebyte(i), msg.getBodyBuffer().readByte());
    }

    msg.acknowledge();
    session.commit();
  }
  private void doTestTransactional(final TestRunner runner) throws Throwable {
    // For duplication detection
    int executionId = 0;

    while (!runner.isFailed()) {
      ClientSession session = null;

      executionId++;

      log.info("#test doTestTransactional starting now. Execution " + executionId);

      try {

        boolean retry = false;

        final int numMessages = 1000;

        session = sf.createSession(false, false);

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

        do {
          try {
            ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);

            for (int i = 0; i < numMessages; i++) {
              ClientMessage message = session.createMessage(true);

              message.getBodyBuffer().writeString("message" + i);

              message.putIntProperty("counter", i);

              message.putStringProperty(
                  Message.HDR_DUPLICATE_DETECTION_ID,
                  new SimpleString("id:" + i + ",exec:" + executionId));

              addPayload(message);

              if (log.isDebugEnabled()) {
                log.debug("Sending message " + message);
              }

              producer.send(message);
            }

            log.debug("Sending commit");
            session.commit();

            retry = false;
          } catch (ActiveMQDuplicateIdException die) {
            logAndSystemOut("#test duplicate id rejected on sending");
            break;
          } catch (ActiveMQTransactionRolledBackException trbe) {
            log.info("#test transaction rollback retrying on sending");
            // OK
            retry = true;
          } catch (ActiveMQUnBlockedException ube) {
            log.info("#test transaction rollback retrying on sending");
            // OK
            retry = true;
          } catch (ActiveMQTransactionOutcomeUnknownException toue) {
            log.info("#test transaction rollback retrying on sending");
            // OK
            retry = true;
          } catch (ActiveMQException e) {
            log.info("#test Exception " + e, e);
            throw e;
          }
        } while (retry);

        logAndSystemOut("#test Finished sending, starting consumption now");

        boolean blocked = false;

        retry = false;

        ClientConsumer consumer = null;
        do {
          ArrayList<Integer> msgs = new ArrayList<>();
          try {
            if (consumer == null) {
              consumer = session.createConsumer(FailoverTestBase.ADDRESS);
              session.start();
            }

            for (int i = 0; i < numMessages; i++) {
              if (log.isDebugEnabled()) {
                log.debug("Consumer receiving message " + i);
              }
              ClientMessage message = consumer.receive(10000);
              if (message == null) {
                break;
              }

              if (log.isDebugEnabled()) {
                log.debug("Received message " + message);
              }

              int count = message.getIntProperty("counter");

              if (count != i) {
                log.warn("count was received out of order, " + count + "!=" + i);
              }

              msgs.add(count);

              message.acknowledge();
            }

            log.info("#test commit");
            try {
              session.commit();
            } catch (ActiveMQTransactionRolledBackException trbe) {
              // we know the tx has been rolled back so we just consume again
              retry = true;
              continue;
            } catch (ActiveMQException e) {
              // This could eventually happen
              // We will get rid of this when we implement 2 phase commit on failover
              log.warn("exception during commit, it will be ignored for now" + e.getMessage(), e);
            }

            try {
              if (blocked) {
                assertTrue(
                    "msgs.size is expected to be 0 or "
                        + numMessages
                        + " but it was "
                        + msgs.size(),
                    msgs.size() == 0 || msgs.size() == numMessages);
              } else {
                assertTrue(
                    "msgs.size is expected to be " + numMessages + " but it was " + msgs.size(),
                    msgs.size() == numMessages);
              }
            } catch (Throwable e) {
              log.info(threadDump("Thread dump, messagesReceived = " + msgs.size()));
              logAndSystemOut(e.getMessage() + " messages received");
              for (Integer msg : msgs) {
                logAndSystemOut(msg.toString());
              }
              throw e;
            }

            int i = 0;
            for (Integer msg : msgs) {
              assertEquals(i++, (int) msg);
            }

            retry = false;
            blocked = false;
          } catch (ActiveMQTransactionRolledBackException trbe) {
            logAndSystemOut("Transaction rolled back with " + msgs.size(), trbe);
            // TODO: https://jira.jboss.org/jira/browse/HORNETQ-369
            // ATM RolledBack exception is being called with the transaction is committed.
            // the test will fail if you remove this next line
            blocked = true;
            retry = true;
          } catch (ActiveMQTransactionOutcomeUnknownException tou) {
            logAndSystemOut("Transaction rolled back with " + msgs.size(), tou);
            // TODO: https://jira.jboss.org/jira/browse/HORNETQ-369
            // ATM RolledBack exception is being called with the transaction is committed.
            // the test will fail if you remove this next line
            blocked = true;
            retry = true;
          } catch (ActiveMQUnBlockedException ube) {
            logAndSystemOut("Unblocked with " + msgs.size(), ube);
            // TODO: https://jira.jboss.org/jira/browse/HORNETQ-369
            // This part of the test is never being called.
            blocked = true;
            retry = true;
          } catch (ActiveMQException e) {
            logAndSystemOut(e.getMessage(), e);
            throw e;
          }
        } while (retry);
      } finally {
        if (session != null) {
          session.close();
        }
      }

      listener = null;
    }
  }
  private void doTestNonTransactional(final TestRunner runner) throws Exception {
    while (!runner.isFailed()) {
      AsynchronousFailoverTest.log.info("looping");

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

      listener = new CountDownSessionFailureListener(session);

      session.addFailureListener(listener);

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

      final int numMessages = 1000;

      for (int i = 0; i < numMessages; i++) {
        boolean retry = false;
        do {
          try {
            ClientMessage message = session.createMessage(true);

            message.getBodyBuffer().writeString("message" + i);

            message.putIntProperty("counter", i);

            addPayload(message);

            producer.send(message);

            retry = false;
          } catch (ActiveMQUnBlockedException ube) {
            AsynchronousFailoverTest.log.info("exception when sending message with counter " + i);

            ube.printStackTrace();

            retry = true;

          } catch (ActiveMQException e) {
            fail("Invalid Exception type:" + e.getType());
          }
        } while (retry);
      }

      // create the consumer with retry if failover occurs during createConsumer call
      ClientConsumer consumer = null;
      boolean retry = false;
      do {
        try {
          consumer = session.createConsumer(FailoverTestBase.ADDRESS);

          retry = false;
        } catch (ActiveMQUnBlockedException ube) {
          AsynchronousFailoverTest.log.info("exception when creating consumer");

          retry = true;

        } catch (ActiveMQException e) {
          fail("Invalid Exception type:" + e.getType());
        }
      } while (retry);

      session.start();

      List<Integer> counts = new ArrayList<>(1000);
      int lastCount = -1;
      boolean counterGap = false;
      while (true) {
        ClientMessage message = consumer.receive(500);

        if (message == null) {
          break;
        }

        // messages must remain ordered but there could be a "jump" if messages
        // are missing or duplicated
        int count = message.getIntProperty("counter");
        counts.add(count);
        if (count != lastCount + 1) {
          if (counterGap) {
            Assert.fail("got another counter gap at " + count + ": " + counts);
          } else {
            if (lastCount != -1) {
              AsynchronousFailoverTest.log.info("got first counter gap at " + count);
              counterGap = true;
            }
          }
        }

        lastCount = count;

        message.acknowledge();
      }

      session.close();

      this.listener = null;
    }
  }
  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(ADDRESS, 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(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(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(ADDRESS);
        sessions[i].start();
      }

      for (int i = 0; i < 100; i++) {
        for (ClientConsumer consumer : consumers) {
          ClientMessage message = consumer.receive(1000);
          assertNotNull("expecting durable msg " + i, message);
          message.acknowledge();
        }
      }
    } finally {
      for (ServerLocator locator : locators) {
        if (locator != null) {
          try {
            locator.close();
          } catch (Exception e) {
            // ignore
          }
        }
      }
    }
  }
  @Test
  public void testStopStartConsumerAsyncSync() throws Exception {
    ClientSessionFactory sf = createSessionFactory(locator);

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

    session.createQueue(QUEUE, QUEUE, null, false);

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 100;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      message.putIntProperty(new SimpleString("i"), i);
      producer.send(message);
    }

    final ClientConsumer consumer = session.createConsumer(QUEUE);

    session.start();

    final CountDownLatch latch = new CountDownLatch(10);

    // Message should be in consumer

    class MyHandler implements MessageHandler {

      boolean failed;

      boolean started = true;

      @Override
      public void onMessage(final ClientMessage message) {

        try {
          if (!started) {
            failed = true;
          }

          latch.countDown();

          if (latch.getCount() == 0) {

            message.acknowledge();
            started = false;
            consumer.setMessageHandler(null);
          }

        } catch (Exception e) {
        }
      }
    }

    MyHandler handler = new MyHandler();

    consumer.setMessageHandler(handler);

    waitForLatch(latch);

    try {
      session.stop();
    } catch (Exception e) {
      SessionStopStartTest.log.warn(e.getMessage(), e);
      throw e;
    }

    Assert.assertFalse(handler.failed);

    // Make sure no exceptions were thrown from onMessage
    Assert.assertNull(consumer.getLastException());
    consumer.setMessageHandler(null);
    session.start();
    for (int i = 0; i < 90; i++) {
      ClientMessage msg = consumer.receive(1000);
      if (msg == null) {
        System.out.println("ClientConsumerTest.testStopConsumer");
      }
      Assert.assertNotNull("message " + i, msg);
      msg.acknowledge();
    }

    Assert.assertNull(consumer.receiveImmediate());

    session.close();
  }
  @Test
  public void testDeployWithFilter() throws Exception {
    final String testAddress = "testAddress";

    final String queueName1 = "queue1";

    final String filter = "cheese='camembert'";

    CoreQueueConfiguration queue1 =
        new CoreQueueConfiguration()
            .setAddress(testAddress)
            .setName(queueName1)
            .setFilterString(filter)
            .setDurable(false);

    configuration.addQueueConfiguration(queue1);

    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(configuration, false));

    server.start();

    ServerLocator locator = createInVMNonHALocator();

    ClientSessionFactory sf = createSessionFactory(locator);

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

    ClientProducer producer = session.createProducer(new SimpleString(testAddress));

    final SimpleString propKey = new SimpleString("testkey");

    final int numMessages = 1;

    PredefinedQueueTest.log.info("sending messages");

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = session.createMessage(true);

      message.putStringProperty(new SimpleString("cheese"), new SimpleString("camembert"));

      message.putIntProperty(propKey, i);

      producer.send(message);
    }

    session.start();

    ClientConsumer consumer1 = session.createConsumer(queueName1);

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = consumer1.receive(200);
      Assert.assertNotNull(message);
      Assert.assertEquals(i, message.getObjectProperty(propKey));
      message.acknowledge();
    }

    Assert.assertNull(consumer1.receiveImmediate());

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = session.createMessage(true);

      message.putStringProperty(new SimpleString("cheese"), new SimpleString("roquefort"));

      message.putIntProperty(propKey, i);

      producer.send(message);
    }

    Assert.assertNull(consumer1.receiveImmediate());
  }