org.apache.activemq.artemis.core.settings.impl.AddressSettings

Here are the examples of the java api class org.apache.activemq.artemis.core.settings.impl.AddressSettings taken from open source projects.

1. AddressSettingsTest#testSingleMerge()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testSingleMerge() {
    AddressSettings addressSettings = new AddressSettings();
    AddressSettings addressSettingsToMerge = new AddressSettings();
    SimpleString DLQ = new SimpleString("testDLQ");
    SimpleString exp = new SimpleString("testExpiryQueue");
    addressSettingsToMerge.setDeadLetterAddress(DLQ);
    addressSettingsToMerge.setExpiryAddress(exp);
    addressSettingsToMerge.setMaxDeliveryAttempts(1000);
    addressSettingsToMerge.setAddressFullMessagePolicy(AddressFullMessagePolicy.DROP);
    addressSettingsToMerge.setMaxSizeBytes(1001);
    addressSettingsToMerge.setMessageCounterHistoryDayLimit(1002);
    addressSettingsToMerge.setRedeliveryDelay(1003);
    addressSettingsToMerge.setPageSizeBytes(1004);
    addressSettings.merge(addressSettingsToMerge);
    Assert.assertEquals(addressSettings.getDeadLetterAddress(), DLQ);
    Assert.assertEquals(addressSettings.getExpiryAddress(), exp);
    Assert.assertEquals(addressSettings.getMaxDeliveryAttempts(), 1000);
    Assert.assertEquals(addressSettings.getMaxSizeBytes(), 1001);
    Assert.assertEquals(addressSettings.getMessageCounterHistoryDayLimit(), 1002);
    Assert.assertEquals(addressSettings.getRedeliveryDelay(), 1003);
    Assert.assertEquals(addressSettings.getPageSizeBytes(), 1004);
    Assert.assertEquals(AddressFullMessagePolicy.DROP, addressSettings.getAddressFullMessagePolicy());
}

2. ArtemisBrokerBase#createServer()

Project: activemq-artemis
File: ArtemisBrokerBase.java
protected final ActiveMQServer createServer(final boolean realFiles, final Configuration configuration, final int pageSize, final int maxAddressSize, final AddressFullMessagePolicy fullPolicy, final Map<String, AddressSettings> settings) {
    ActiveMQServer server = ActiveMQServers.newActiveMQServer(configuration, realFiles);
    if (settings != null) {
        for (Map.Entry<String, AddressSettings> setting : settings.entrySet()) {
            server.getAddressSettingsRepository().addMatch(setting.getKey(), setting.getValue());
        }
    }
    AddressSettings defaultSetting = new AddressSettings();
    defaultSetting.setPageSizeBytes(pageSize);
    defaultSetting.setMaxSizeBytes(maxAddressSize);
    defaultSetting.setAddressFullMessagePolicy(fullPolicy);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    return server;
}

3. MQTTTestSupport#startBroker()

Project: activemq-artemis
File: MQTTTestSupport.java
public void startBroker() throws Exception {
    // TODO Add SSL
    super.setUp();
    server = createServer(true, true);
    addCoreConnector();
    addMQTTConnector();
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setMaxSizeBytes(999999999);
    addressSettings.setAutoCreateJmsQueues(true);
    server.getAddressSettingsRepository().addMatch("#", addressSettings);
    server.start();
    server.waitForActivation(10, TimeUnit.SECONDS);
}

4. QueueFactoryImpl#createQueue()

Project: activemq-artemis
File: QueueFactoryImpl.java
@Override
public Queue createQueue(final long persistenceID, final SimpleString address, final SimpleString name, final Filter filter, final PageSubscription pageSubscription, final SimpleString user, final boolean durable, final boolean temporary, final boolean autoCreated) {
    AddressSettings addressSettings = addressSettingsRepository.getMatch(address.toString());
    Queue queue;
    if (addressSettings.isLastValueQueue()) {
        queue = new LastValueQueue(persistenceID, address, name, filter, pageSubscription, user, durable, temporary, autoCreated, scheduledExecutor, postOffice, storageManager, addressSettingsRepository, executorFactory.getExecutor());
    } else {
        queue = new QueueImpl(persistenceID, address, name, filter, pageSubscription, user, durable, temporary, autoCreated, scheduledExecutor, postOffice, storageManager, addressSettingsRepository, executorFactory.getExecutor());
    }
    return queue;
}

5. SessionTest#testCreateQueueWhileTopicWithSameNameExists()

Project: activemq-artemis
File: SessionTest.java
@Test
public void testCreateQueueWhileTopicWithSameNameExists() throws Exception {
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setAutoCreateJmsQueues(false);
    getJmsServer().getAddressSettingsRepository().addMatch("#", addressSettings);
    Connection conn = getConnectionFactory().createConnection();
    Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    try {
        sess.createQueue("TestTopic");
        ProxyAssertSupport.fail("should throw JMSException");
    } catch (JMSException e) {
    }
    conn.close();
}

6. SessionTest#testCreateNonExistentQueue()

Project: activemq-artemis
File: SessionTest.java
//
// createQueue()/createTopic()
//
@Test
public void testCreateNonExistentQueue() throws Exception {
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setAutoCreateJmsQueues(false);
    getJmsServer().getAddressSettingsRepository().addMatch("#", addressSettings);
    Connection conn = getConnectionFactory().createConnection();
    Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    try {
        sess.createQueue("QueueThatDoesNotExist");
        ProxyAssertSupport.fail();
    } catch (JMSException e) {
    }
    conn.close();
}

7. StompV12Test#testSendMessageToNonExistentJmsQueueWithoutAutoCreation()

Project: activemq-artemis
File: StompV12Test.java
@Test
public void testSendMessageToNonExistentJmsQueueWithoutAutoCreation() throws Exception {
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setAutoCreateJmsQueues(false);
    server.getActiveMQServer().getAddressSettingsRepository().addMatch("#", addressSettings);
    connV12.connect(defUser, defPass);
    ClientStompFrame frame = connV12.createFrame("SEND");
    String guid = UUID.randomUUID().toString();
    frame.addHeader("destination", "jms.queue.NonExistentQueue" + guid);
    frame.addHeader("receipt", "1234");
    frame.setBody("Hello World");
    frame = connV12.sendFrame(frame);
    Assert.assertTrue(frame.getCommand().equals("ERROR"));
    Assert.assertEquals("1234", frame.getHeader("receipt-id"));
    System.out.println("message: " + frame.getHeader("message"));
    waitDisconnect(connV12);
    Assert.assertFalse("Should be disconnected in STOMP 1.2 after ERROR", connV12.isConnected());
}

8. StompV11Test#testSendMessageToNonExistentJmsQueueWithoutAutoCreation()

Project: activemq-artemis
File: StompV11Test.java
@Test
public void testSendMessageToNonExistentJmsQueueWithoutAutoCreation() throws Exception {
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setAutoCreateJmsQueues(false);
    server.getActiveMQServer().getAddressSettingsRepository().addMatch("#", addressSettings);
    connV11.connect(defUser, defPass);
    ClientStompFrame frame = connV11.createFrame("SEND");
    String guid = UUID.randomUUID().toString();
    frame.addHeader("destination", "jms.queue.NonExistentQueue" + guid);
    frame.addHeader("receipt", "1234");
    frame.setBody("Hello World");
    frame = connV11.sendFrame(frame);
    assertTrue(frame.getCommand().equals("ERROR"));
    assertEquals("1234", frame.getHeader("receipt-id"));
    System.out.println("message: " + frame.getHeader("message"));
    connV11.disconnect();
}

9. SimpleOpenWireTest#testAutoDestinationNoCreationOnConsumer()

Project: activemq-artemis
File: SimpleOpenWireTest.java
@Test
public void testAutoDestinationNoCreationOnConsumer() throws JMSException {
    AddressSettings addressSetting = new AddressSettings();
    addressSetting.setAutoCreateJmsQueues(false);
    String address = "foo";
    server.getAddressSettingsRepository().addMatch("jms.queue." + address, addressSetting);
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    TextMessage message = session.createTextMessage("bar");
    Queue queue = new ActiveMQQueue(address);
    try {
        MessageConsumer consumer = session.createConsumer(queue);
        fail("supposed to throw an exception here");
    } catch (JMSException e) {
    }
}

10. SimpleOpenWireTest#testAutoDestinationCreationOnConsumer()

Project: activemq-artemis
File: SimpleOpenWireTest.java
@Test
public void testAutoDestinationCreationOnConsumer() throws JMSException {
    AddressSettings addressSetting = new AddressSettings();
    addressSetting.setAutoCreateJmsQueues(true);
    String address = "foo";
    server.getAddressSettingsRepository().addMatch("jms.queue." + address, addressSetting);
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    TextMessage message = session.createTextMessage("bar");
    Queue queue = new ActiveMQQueue(address);
    MessageConsumer consumer = session.createConsumer(queue);
    MessageProducer producer = session.createProducer(null);
    producer.send(queue, message);
    TextMessage message1 = (TextMessage) consumer.receive(1000);
    assertTrue(message1.getText().equals(message.getText()));
}

11. SimpleOpenWireTest#testAutoDestinationCreationOnProducerSend()

Project: activemq-artemis
File: SimpleOpenWireTest.java
@Test
public void testAutoDestinationCreationOnProducerSend() throws JMSException {
    AddressSettings addressSetting = new AddressSettings();
    addressSetting.setAutoCreateJmsQueues(true);
    String address = "foo";
    server.getAddressSettingsRepository().addMatch("jms.queue." + address, addressSetting);
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    TextMessage message = session.createTextMessage("bar");
    Queue queue = new ActiveMQQueue(address);
    MessageProducer producer = session.createProducer(null);
    producer.send(queue, message);
    MessageConsumer consumer = session.createConsumer(queue);
    TextMessage message1 = (TextMessage) consumer.receive(1000);
    assertTrue(message1.getText().equals(message.getText()));
}

12. SimpleOpenWireTest#testInvalidDestinationExceptionWhenNoQueueExistsOnCreateProducer()

Project: activemq-artemis
File: SimpleOpenWireTest.java
@Test
public void testInvalidDestinationExceptionWhenNoQueueExistsOnCreateProducer() throws Exception {
    AddressSettings addressSetting = new AddressSettings();
    addressSetting.setAutoCreateJmsQueues(false);
    server.getAddressSettingsRepository().addMatch("jms.queue.foo", addressSetting);
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue("foo");
    try {
        session.createProducer(queue);
    } catch (JMSException expected) {
    }
    session.close();
}

13. AddressControlTest#testGetNumberOfBytesPerPage()

Project: activemq-artemis
File: AddressControlTest.java
@Test
public void testGetNumberOfBytesPerPage() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    session.createQueue(address, address, true);
    AddressControl addressControl = createManagementControl(address);
    Assert.assertEquals(ActiveMQDefaultConfiguration.getDefaultJournalFileSize(), addressControl.getNumberOfBytesPerPage());
    session.close();
    server.stop();
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setPageSizeBytes(1024);
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    server.start();
    ServerLocator locator2 = createInVMNonHALocator();
    ClientSessionFactory sf2 = createSessionFactory(locator2);
    session = sf2.createSession(false, true, false);
    session.createQueue(address, address, true);
    Assert.assertEquals(1024, addressControl.getNumberOfBytesPerPage());
}

14. ExpireTestOnRestartTest#setUp()

Project: activemq-artemis
File: ExpireTestOnRestartTest.java
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    server = createServer(true);
    AddressSettings setting = new AddressSettings().setExpiryAddress(SimpleString.toSimpleString("exp")).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setPageSizeBytes(100 * 1024).setMaxSizeBytes(200 * 1024);
    server.getConfiguration().setJournalSyncNonTransactional(false);
    server.getConfiguration().setMessageExpiryScanPeriod(-1);
    server.getConfiguration().setJournalSyncTransactional(false);
    server.getAddressSettingsRepository().addMatch("#", setting);
    server.start();
}

15. DeadLetterAddressTest#testBasicSendToNoQueue()

Project: activemq-artemis
File: DeadLetterAddressTest.java
@Test
public void testBasicSendToNoQueue() throws Exception {
    SimpleString qName = new SimpleString("q1");
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1);
    server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
    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(500);
    m.acknowledge();
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
    // force a cancel
    clientSession.rollback();
    m = clientConsumer.receiveImmediate();
    Assert.assertNull(m);
    clientConsumer.close();
}

16. DeadLetterAddressTest#testReceiveWithListeners()

Project: activemq-artemis
File: DeadLetterAddressTest.java
@Test
public void testReceiveWithListeners() 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!"));
    ClientConsumer clientConsumer = clientSession.createConsumer(qName);
    final CountDownLatch latch = new CountDownLatch(2);
    TestHandler handler = new TestHandler(latch, clientSession);
    clientConsumer.setMessageHandler(handler);
    clientSession.start();
    assertTrue(latch.await(5, TimeUnit.SECONDS));
    assertEquals(handler.count, 2);
    clientConsumer = clientSession.createConsumer(dlq);
    Message m = clientConsumer.receive(5000);
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
}

17. DeadLetterAddressTest#testBasicSendWithDLAButNoBinding()

Project: activemq-artemis
File: DeadLetterAddressTest.java
// HORNETQ- 1084
@Test
public void testBasicSendWithDLAButNoBinding() throws Exception {
    SimpleString dla = new SimpleString("DLA");
    SimpleString qName = new SimpleString("q1");
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1).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(500);
    m.acknowledge();
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
    // force a cancel
    clientSession.rollback();
    m = clientConsumer.receiveImmediate();
    Assert.assertNull(m);
    clientConsumer.close();
    Queue q = (Queue) server.getPostOffice().getBinding(qName).getBindable();
    Assert.assertEquals(0, q.getDeliveringCount());
}

18. ActiveMQTestBase#createServer()

Project: activemq-artemis
File: ActiveMQTestBase.java
protected final ActiveMQServer createServer(final boolean realFiles, final Configuration configuration, final long pageSize, final long maxAddressSize, final Map<String, AddressSettings> settings) {
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(configuration, realFiles));
    if (settings != null) {
        for (Map.Entry<String, AddressSettings> setting : settings.entrySet()) {
            server.getAddressSettingsRepository().addMatch(setting.getKey(), setting.getValue());
        }
    }
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(pageSize).setMaxSizeBytes(maxAddressSize).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    return server;
}

19. AddressSettingsTest#testDefaults()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testDefaults() {
    AddressSettings addressSettings = new AddressSettings();
    Assert.assertEquals(null, addressSettings.getDeadLetterAddress());
    Assert.assertEquals(null, addressSettings.getExpiryAddress());
    Assert.assertEquals(AddressSettings.DEFAULT_MAX_DELIVERY_ATTEMPTS, addressSettings.getMaxDeliveryAttempts());
    Assert.assertEquals(addressSettings.getMaxSizeBytes(), AddressSettings.DEFAULT_MAX_SIZE_BYTES);
    Assert.assertEquals(AddressSettings.DEFAULT_PAGE_SIZE, addressSettings.getPageSizeBytes());
    Assert.assertEquals(AddressSettings.DEFAULT_MESSAGE_COUNTER_HISTORY_DAY_LIMIT, addressSettings.getMessageCounterHistoryDayLimit());
    Assert.assertEquals(AddressSettings.DEFAULT_REDELIVER_DELAY, addressSettings.getRedeliveryDelay());
    Assert.assertEquals(AddressSettings.DEFAULT_REDELIVER_MULTIPLIER, addressSettings.getRedeliveryMultiplier(), 0.000001);
    Assert.assertEquals(AddressSettings.DEFAULT_SLOW_CONSUMER_THRESHOLD, addressSettings.getSlowConsumerThreshold());
    Assert.assertEquals(AddressSettings.DEFAULT_SLOW_CONSUMER_CHECK_PERIOD, addressSettings.getSlowConsumerCheckPeriod());
    Assert.assertEquals(AddressSettings.DEFAULT_SLOW_CONSUMER_POLICY, addressSettings.getSlowConsumerPolicy());
    Assert.assertEquals(AddressSettings.DEFAULT_AUTO_CREATE_QUEUES, addressSettings.isAutoCreateJmsQueues());
    Assert.assertEquals(AddressSettings.DEFAULT_AUTO_DELETE_QUEUES, addressSettings.isAutoDeleteJmsQueues());
    Assert.assertEquals(AddressSettings.DEFAULT_AUTO_CREATE_TOPICS, addressSettings.isAutoCreateJmsTopics());
    Assert.assertEquals(AddressSettings.DEFAULT_AUTO_DELETE_TOPICS, addressSettings.isAutoDeleteJmsTopics());
}

20. AbstractSendReceivePerfTest#setUp()

Project: activemq-artemis
File: AbstractSendReceivePerfTest.java
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    jmsServer.createQueue(false, Q_NAME, null, true, Q_NAME);
    queue = ActiveMQJMSClient.createQueue(Q_NAME);
    AddressSettings settings = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.BLOCK).setMaxSizeBytes(Long.MAX_VALUE);
    server.getAddressSettingsRepository().clear();
    server.getAddressSettingsRepository().addMatch("#", settings);
}

21. ExpiryRunnerTest#setUp()

Project: activemq-artemis
File: ExpiryRunnerTest.java
//
//   public static void main(final String[] args) throws Exception
//   {
//      for (int i = 0; i < 1000; i++)
//      {
//         TestSuite suite = new TestSuite();
//         ExpiryRunnerTest expiryRunnerTest = new ExpiryRunnerTest();
//         expiryRunnerTest.setName("testExpireWhilstConsuming");
//         suite.addTest(expiryRunnerTest);
//
//         TestResult result = TestRunner.run(suite);
//         if (result.errorCount() > 0 || result.failureCount() > 0)
//         {
//            System.exit(1);
//         }
//      }
//   }
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    ConfigurationImpl configuration = (ConfigurationImpl) createDefaultInVMConfig().setMessageExpiryScanPeriod(1000);
    server = addServer(ActiveMQServers.newActiveMQServer(configuration, false));
    // start the server
    server.start();
    // then we create a client as normal
    locator = createInVMNonHALocator().setBlockOnAcknowledge(true);
    ClientSessionFactory sessionFactory = createSessionFactory(locator);
    clientSession = sessionFactory.createSession(false, true, true);
    clientSession.createQueue(qName, qName, null, false);
    expiryAddress = new SimpleString("EA");
    expiryQueue = new SimpleString("expiryQ");
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(expiryAddress);
    server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
    server.getAddressSettingsRepository().addMatch(qName2.toString(), addressSettings);
    clientSession.createQueue(expiryAddress, expiryQueue, null, false);
}

22. ExpiryRunnerTest#testExpireFromMultipleQueues()

Project: activemq-artemis
File: ExpiryRunnerTest.java
@Test
public void testExpireFromMultipleQueues() throws Exception {
    ClientProducer producer = clientSession.createProducer(qName);
    clientSession.createQueue(qName2, qName2, null, false);
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(expiryAddress);
    server.getAddressSettingsRepository().addMatch(qName2.toString(), addressSettings);
    ClientProducer producer2 = clientSession.createProducer(qName2);
    int numMessages = 100;
    long expiration = System.currentTimeMillis();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage m = createTextMessage(clientSession, "m" + i);
        m.setExpiration(expiration);
        producer.send(m);
        m = createTextMessage(clientSession, "m" + i);
        m.setExpiration(expiration);
        producer2.send(m);
    }
    Thread.sleep(1600);
    Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(qName).getBindable()).getMessageCount());
    Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(qName).getBindable()).getDeliveringCount());
}

23. PagingCounterTest#newActiveMQServer()

Project: activemq-artemis
File: PagingCounterTest.java
private ActiveMQServer newActiveMQServer() throws Exception {
    OperationContextImpl.clearContext();
    ActiveMQServer server = super.createServer(true, false);
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    return server;
}

24. QueueControlTest#testSetExpiryAddress()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testSetExpiryAddress() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    String expiryAddress = RandomUtil.randomString();
    session.createQueue(address, queue, null, false);
    QueueControl queueControl = createManagementControl(address, queue);
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(new SimpleString(expiryAddress));
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    Assert.assertEquals(expiryAddress, queueControl.getExpiryAddress());
    Queue serverqueue = server.locateQueue(queue);
    assertEquals(expiryAddress, serverqueue.getExpiryAddress().toString());
    session.deleteQueue(queue);
}

25. QueueControlTest#testSetDeadLetterAddress()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testSetDeadLetterAddress() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    String deadLetterAddress = RandomUtil.randomString();
    session.createQueue(address, queue, null, false);
    QueueControl queueControl = createManagementControl(address, queue);
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(new SimpleString(deadLetterAddress));
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    Assert.assertEquals(deadLetterAddress, queueControl.getDeadLetterAddress());
    session.deleteQueue(queue);
}

26. ManagementWithPagingServerTest#setUp()

Project: activemq-artemis
File: ManagementWithPagingServerTest.java
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    Configuration config = createDefaultInVMConfig().setJMXManagementEnabled(true);
    server = addServer(ActiveMQServers.newActiveMQServer(config, mbeanServer, true));
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(5120).setMaxSizeBytes(10240).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    server.start();
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(false).setConsumerWindowSize(0);
    ClientSessionFactory sf = createSessionFactory(locator);
    session1 = sf.createSession(false, true, false);
    session1.start();
    session2 = sf.createSession(false, true, false);
    session2.start();
}

27. JMSQueueControlTest#testSetDeadLetterAddress()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testSetDeadLetterAddress() throws Exception {
    final String deadLetterAddress = RandomUtil.randomString();
    JMSQueueControl queueControl = createManagementControl();
    Assert.assertNull(queueControl.getDeadLetterAddress());
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(new SimpleString(deadLetterAddress));
    server.getAddressSettingsRepository().addMatch(queue.getAddress(), addressSettings);
    Assert.assertEquals(deadLetterAddress, queueControl.getDeadLetterAddress());
}

28. JMSQueueControlTest#testSetExpiryAddress()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testSetExpiryAddress() throws Exception {
    final String expiryAddress = RandomUtil.randomString();
    JMSQueueControl queueControl = createManagementControl();
    Assert.assertNull(queueControl.getExpiryAddress());
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(new SimpleString(expiryAddress));
    server.getAddressSettingsRepository().addMatch(queue.getAddress(), addressSettings);
    Assert.assertEquals(expiryAddress, queueControl.getExpiryAddress());
}

29. SlowConsumerTest#setUp()

Project: activemq-artemis
File: SlowConsumerTest.java
@Before
@Override
public void setUp() throws Exception {
    super.setUp();
    server = createServer(false, isNetty);
    AddressSettings addressSettings = new AddressSettings().setSlowConsumerCheckPeriod(2).setSlowConsumerThreshold(10).setSlowConsumerPolicy(SlowConsumerPolicy.KILL);
    server.start();
    server.getAddressSettingsRepository().addMatch(QUEUE.toString(), addressSettings);
    locator = createFactory(isNetty);
}

30. NIOvsOIOTest#testPerf()

Project: activemq-artemis
File: NIOvsOIOTest.java
private void testPerf(boolean nio) throws Exception {
    Configuration config = createDefaultInVMConfig();
    Map<String, Object> params = new HashMap<>();
    params.put(TransportConstants.USE_NIO_PROP_NAME, nio);
    config.getAcceptorConfigurations().add(new TransportConfiguration(NETTY_ACCEPTOR_FACTORY, params));
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config, false));
    AddressSettings addressSettings = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.BLOCK).setMaxSizeBytes(10 * 1024 * 1024);
    final String dest = "test-destination";
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(dest, addressSettings);
    server.start();
    for (int i = 0; i < 2; i++) {
        doTest(dest);
    }
}

31. NewDeadLetterAddressTest#testSendToDLAWhenNoRoute()

Project: activemq-artemis
File: NewDeadLetterAddressTest.java
@Test
public void testSendToDLAWhenNoRoute() throws Exception {
    SimpleString dla = new SimpleString("DLA");
    SimpleString address = new SimpleString("empty_address");
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dla).setSendToDLAOnNoRoute(true);
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    SimpleString dlq = new SimpleString("DLQ1");
    clientSession.createQueue(dla, dlq, null, false);
    ClientProducer producer = clientSession.createProducer(address);
    producer.send(createTextMessage(clientSession, "heyho!"));
    clientSession.start();
    ClientConsumer clientConsumer = clientSession.createConsumer(dlq);
    ClientMessage m = clientConsumer.receive(500);
    m.acknowledge();
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
}

32. MessageConsumerRollbackTest#setUp()

Project: activemq-artemis
File: MessageConsumerRollbackTest.java
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    server = createServer(true, true);
    AddressSettings settings = new AddressSettings().setRedeliveryDelay(100);
    server.getConfiguration().getAddressesSettings().put("#", settings);
    server.start();
    locator = createNettyNonHALocator();
    sf = createSessionFactory(locator);
    ClientSession session = sf.createTransactedSession();
    session.createQueue(inQueue, inQueue, true);
    session.createQueue(outQueue, outQueue, true);
    session.close();
}

33. AddressSettingsTest#testMultipleMergeAll()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testMultipleMergeAll() {
    AddressSettings addressSettings = new AddressSettings();
    AddressSettings addressSettingsToMerge = new AddressSettings();
    SimpleString DLQ = new SimpleString("testDLQ");
    SimpleString exp = new SimpleString("testExpiryQueue");
    addressSettingsToMerge.setDeadLetterAddress(DLQ);
    addressSettingsToMerge.setExpiryAddress(exp);
    addressSettingsToMerge.setMaxSizeBytes(1001);
    addressSettingsToMerge.setRedeliveryDelay(1003);
    addressSettingsToMerge.setRedeliveryMultiplier(1.0);
    addressSettingsToMerge.setAddressFullMessagePolicy(AddressFullMessagePolicy.DROP);
    addressSettings.merge(addressSettingsToMerge);
    AddressSettings addressSettingsToMerge2 = new AddressSettings();
    SimpleString exp2 = new SimpleString("testExpiryQueue2");
    SimpleString DLQ2 = new SimpleString("testDlq2");
    addressSettingsToMerge2.setExpiryAddress(exp2);
    addressSettingsToMerge2.setDeadLetterAddress(DLQ2);
    addressSettingsToMerge2.setMaxDeliveryAttempts(2000);
    addressSettingsToMerge2.setMaxSizeBytes(2001);
    addressSettingsToMerge2.setMessageCounterHistoryDayLimit(2002);
    addressSettingsToMerge2.setRedeliveryDelay(2003);
    addressSettingsToMerge2.setRedeliveryMultiplier(2.0);
    addressSettingsToMerge2.setMaxRedeliveryDelay(5000);
    addressSettingsToMerge.setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    addressSettings.merge(addressSettingsToMerge2);
    Assert.assertEquals(addressSettings.getDeadLetterAddress(), DLQ);
    Assert.assertEquals(addressSettings.getExpiryAddress(), exp);
    Assert.assertEquals(addressSettings.getMaxDeliveryAttempts(), 2000);
    Assert.assertEquals(addressSettings.getMaxSizeBytes(), 1001);
    Assert.assertEquals(addressSettings.getMessageCounterHistoryDayLimit(), 2002);
    Assert.assertEquals(addressSettings.getRedeliveryDelay(), 1003);
    Assert.assertEquals(addressSettings.getRedeliveryMultiplier(), 1.0, 0.000001);
    Assert.assertEquals(addressSettings.getMaxRedeliveryDelay(), 5000);
    Assert.assertEquals(AddressFullMessagePolicy.DROP, addressSettings.getAddressFullMessagePolicy());
}

34. ActiveMQServerControlImpl#addAddressSettings()

Project: activemq-artemis
File: ActiveMQServerControlImpl.java
@Override
public void addAddressSettings(final String address, final String DLA, final String expiryAddress, final long expiryDelay, final boolean lastValueQueue, final int deliveryAttempts, final long maxSizeBytes, final int pageSizeBytes, final int pageMaxCacheSize, final long redeliveryDelay, final double redeliveryMultiplier, final long maxRedeliveryDelay, final long redistributionDelay, final boolean sendToDLAOnNoRoute, final String addressFullMessagePolicy, final long slowConsumerThreshold, final long slowConsumerCheckPeriod, final String slowConsumerPolicy, final boolean autoCreateJmsQueues, final boolean autoDeleteJmsQueues, final boolean autoCreateJmsTopics, final boolean autoDeleteJmsTopics) throws Exception {
    checkStarted();
    // JBPAPP-6334 requested this to be pageSizeBytes > maxSizeBytes
    if (pageSizeBytes > maxSizeBytes && maxSizeBytes > 0) {
        throw new IllegalStateException("pageSize has to be lower than maxSizeBytes. Invalid argument (" + pageSizeBytes + " < " + maxSizeBytes + ")");
    }
    if (maxSizeBytes < -1) {
        throw new IllegalStateException("Invalid argument on maxSizeBytes");
    }
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setDeadLetterAddress(DLA == null ? null : new SimpleString(DLA));
    addressSettings.setExpiryAddress(expiryAddress == null ? null : new SimpleString(expiryAddress));
    addressSettings.setExpiryDelay(expiryDelay);
    addressSettings.setLastValueQueue(lastValueQueue);
    addressSettings.setMaxDeliveryAttempts(deliveryAttempts);
    addressSettings.setPageCacheMaxSize(pageMaxCacheSize);
    addressSettings.setMaxSizeBytes(maxSizeBytes);
    addressSettings.setPageSizeBytes(pageSizeBytes);
    addressSettings.setRedeliveryDelay(redeliveryDelay);
    addressSettings.setRedeliveryMultiplier(redeliveryMultiplier);
    addressSettings.setMaxRedeliveryDelay(maxRedeliveryDelay);
    addressSettings.setRedistributionDelay(redistributionDelay);
    addressSettings.setSendToDLAOnNoRoute(sendToDLAOnNoRoute);
    if (addressFullMessagePolicy == null) {
        addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    } else if (addressFullMessagePolicy.equalsIgnoreCase("PAGE")) {
        addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    } else if (addressFullMessagePolicy.equalsIgnoreCase("DROP")) {
        addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.DROP);
    } else if (addressFullMessagePolicy.equalsIgnoreCase("BLOCK")) {
        addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.BLOCK);
    } else if (addressFullMessagePolicy.equalsIgnoreCase("FAIL")) {
        addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL);
    }
    addressSettings.setSlowConsumerThreshold(slowConsumerThreshold);
    addressSettings.setSlowConsumerCheckPeriod(slowConsumerCheckPeriod);
    if (slowConsumerPolicy == null) {
        addressSettings.setSlowConsumerPolicy(SlowConsumerPolicy.NOTIFY);
    } else if (slowConsumerPolicy.equalsIgnoreCase("NOTIFY")) {
        addressSettings.setSlowConsumerPolicy(SlowConsumerPolicy.NOTIFY);
    } else if (slowConsumerPolicy.equalsIgnoreCase("KILL")) {
        addressSettings.setSlowConsumerPolicy(SlowConsumerPolicy.KILL);
    }
    addressSettings.setAutoCreateJmsQueues(autoCreateJmsQueues);
    addressSettings.setAutoDeleteJmsQueues(autoDeleteJmsQueues);
    addressSettings.setAutoCreateJmsTopics(autoCreateJmsTopics);
    addressSettings.setAutoDeleteJmsTopics(autoDeleteJmsTopics);
    server.getAddressSettingsRepository().addMatch(address, addressSettings);
    storageManager.storeAddressSetting(new PersistedAddressSetting(new SimpleString(address), addressSettings));
}

35. MultipleProducersTest#wrongQueue()

Project: activemq-artemis
File: MultipleProducersTest.java
@Test
public void wrongQueue() throws Exception {
    conn = cf.createConnection();
    session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL);
    addressSettings.setExpiryAddress(dlq);
    addressSettings.setDeadLetterAddress(expiryQueue);
    addressSettings.setRedeliveryDelay(0);
    addressSettings.setMessageCounterHistoryDayLimit(2);
    addressSettings.setLastValueQueue(false);
    addressSettings.setMaxDeliveryAttempts(10);
    addressSettings.setMaxSizeBytes(1048576);
    addressSettings.setPageCacheMaxSize(5);
    addressSettings.setPageSizeBytes(2097152);
    addressSettings.setRedistributionDelay(-1);
    addressSettings.setSendToDLAOnNoRoute(false);
    addressSettings.setSlowConsumerCheckPeriod(5);
    addressSettings.setSlowConsumerPolicy(SlowConsumerPolicy.NOTIFY);
    addressSettings.setSlowConsumerThreshold(-1);
    repos.setDefault(addressSettings);
    queueOne = createQueue("queueOne");
    queueTwo = createQueue("queueTwo");
    try {
        while (true) {
            sendMessage(queueOne, session);
        }
    } catch (Throwable t) {
    }
    session.close();
    conn.close();
    session = null;
    conn = null;
    conn = cf.createConnection();
    session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    // result an exception
    try {
        sendMessage(queueOne, session);
        Assert.fail("Exception expected");
    } catch (Exception t) {
    }
    // there shoudl be 5 messages on queueTwo
    for (int i = 0; i < 5; i++) {
        sendMessage(queueTwo, session);
    }
    // before sending any messages to queueOne it has to be drained.
    // after draining queueOne send 5 message to queueOne
    queueTwoMsgCount = server.locateQueue(queueTwoName).getMessageCount();
    control = (JMSQueueControl) server.getManagementService().getResource(ResourceNames.JMS_QUEUE + queueOne.getQueueName());
    control.removeMessages(null);
    for (int i = 0; i < 5; i++) {
        sendMessage(queueOne, session);
    }
    // at the end of the test there shoudl be 5 message on queueOne and 5 messages on queueTwo
    session.close();
    conn.close();
    queueOneMsgCount = server.locateQueue(queueOneName).getMessageCount();
    queueTwoMsgCount = server.locateQueue(queueTwoName).getMessageCount();
    Assert.assertEquals("queueTwo message count", 5, queueTwoMsgCount);
    Assert.assertEquals("queueOne message count", 5, queueOneMsgCount);
}

36. AddressSettingsTest#testMultipleMerge()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testMultipleMerge() {
    AddressSettings addressSettings = new AddressSettings();
    AddressSettings addressSettingsToMerge = new AddressSettings();
    SimpleString DLQ = new SimpleString("testDLQ");
    SimpleString exp = new SimpleString("testExpiryQueue");
    addressSettingsToMerge.setDeadLetterAddress(DLQ);
    addressSettingsToMerge.setExpiryAddress(exp);
    addressSettingsToMerge.setMaxDeliveryAttempts(1000);
    addressSettingsToMerge.setMaxSizeBytes(1001);
    addressSettingsToMerge.setMessageCounterHistoryDayLimit(1002);
    addressSettingsToMerge.setAddressFullMessagePolicy(AddressFullMessagePolicy.DROP);
    addressSettings.merge(addressSettingsToMerge);
    AddressSettings addressSettingsToMerge2 = new AddressSettings();
    SimpleString exp2 = new SimpleString("testExpiryQueue2");
    addressSettingsToMerge2.setExpiryAddress(exp2);
    addressSettingsToMerge2.setMaxSizeBytes(2001);
    addressSettingsToMerge2.setRedeliveryDelay(2003);
    addressSettingsToMerge2.setRedeliveryMultiplier(2.5);
    addressSettings.merge(addressSettingsToMerge2);
    Assert.assertEquals(addressSettings.getDeadLetterAddress(), DLQ);
    Assert.assertEquals(addressSettings.getExpiryAddress(), exp);
    Assert.assertEquals(addressSettings.getMaxDeliveryAttempts(), 1000);
    Assert.assertEquals(addressSettings.getMaxSizeBytes(), 1001);
    Assert.assertEquals(addressSettings.getMessageCounterHistoryDayLimit(), 1002);
    Assert.assertEquals(addressSettings.getRedeliveryDelay(), 2003);
    Assert.assertEquals(addressSettings.getRedeliveryMultiplier(), 2.5, 0.000001);
    Assert.assertEquals(AddressFullMessagePolicy.DROP, addressSettings.getAddressFullMessagePolicy());
}

37. AddressSettingsTest#testOverrideHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testOverrideHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setMaxDeliveryAttempts(1);
    AddressSettings addressSettings3 = new AddressSettings().setDeadLetterAddress(dlaC).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA2.toString(), addressSettings);
    repos.addMatch("add.*", addressSettings2);
    repos.addMatch("#", addressSettings3);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA2, queueA, false);
    session.createQueue(addressB2, queueB, false);
    session.createQueue(addressC, queueC, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    session.createQueue(dlaC, dlqC, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    ClientMessage cm2 = sendSession.createMessage(true);
    ClientMessage cm3 = sendSession.createMessage(true);
    ClientProducer cp1 = sendSession.createProducer(addressA2);
    ClientProducer cp2 = sendSession.createProducer(addressB2);
    ClientProducer cp3 = sendSession.createProducer(addressC);
    cp1.send(cm);
    cp2.send(cm2);
    cp3.send(cm3);
    ClientConsumer dlqCrec = session.createConsumer(dlqC);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    ClientConsumer cc3 = session.createConsumer(queueC);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc3.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    cc3.close();
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    sendSession.close();
    session.close();
}

38. AddressSettingsTest#test3LevelHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void test3LevelHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings3 = new AddressSettings().setDeadLetterAddress(dlaC).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA2.toString(), addressSettings);
    repos.addMatch("add.*", addressSettings2);
    repos.addMatch("#", addressSettings3);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA2, queueA, false);
    session.createQueue(addressB2, queueB, false);
    session.createQueue(addressC, queueC, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    session.createQueue(dlaC, dlqC, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientMessage cm3 = sendSession.createMessage(true);
    cm3.getBodyBuffer().writeString("C");
    ClientProducer cp1 = sendSession.createProducer(addressA2);
    ClientProducer cp2 = sendSession.createProducer(addressB2);
    ClientProducer cp3 = sendSession.createProducer(addressC);
    cp1.send(cm);
    cp2.send(cm2);
    cp3.send(cm3);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer dlqCrec = session.createConsumer(dlqC);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    ClientConsumer cc3 = session.createConsumer(queueC);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc3.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    cc3.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("C", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

39. ArtemisBrokerWrapper#start()

Project: activemq-artemis
File: ArtemisBrokerWrapper.java
@Override
public void start() throws Exception {
    clearDataRecreateServerDirs();
    mbeanServer = MBeanServerFactory.createMBeanServer();
    server = createServer(realStore, true);
    server.setMBeanServer(mbeanServer);
    server.getConfiguration().getAcceptorConfigurations().clear();
    Configuration serverConfig = server.getConfiguration();
    serverConfig.setJMXManagementEnabled(true);
    Map<String, AddressSettings> addressSettingsMap = serverConfig.getAddressesSettings();
    //do policy translation
    PolicyMap policyMap = this.bservice.getDestinationPolicy();
    if (policyMap != null) {
        translatePolicyMap(serverConfig, policyMap);
    }
    String match = "jms.queue.#";
    AddressSettings commonSettings = addressSettingsMap.get(match);
    if (commonSettings == null) {
        commonSettings = new AddressSettings();
        addressSettingsMap.put(match, commonSettings);
    }
    SimpleString dla = new SimpleString("jms.queue.ActiveMQ.DLQ");
    commonSettings.setDeadLetterAddress(dla);
    commonSettings.setAutoCreateJmsQueues(true);
    if (bservice.extraConnectors.size() == 0) {
        serverConfig.addAcceptorConfiguration("home", "tcp://localhost:61616");
    }
    for (BrokerService.ConnectorInfo info : bservice.extraConnectors) {
        addServerAcceptor(serverConfig, info);
    }
    serverConfig.setSecurityEnabled(enableSecurity);
    if (enableSecurity) {
        ActiveMQJAASSecurityManager sm = (ActiveMQJAASSecurityManager) server.getSecurityManager();
        SecurityConfiguration securityConfig = sm.getConfiguration();
        securityConfig.addRole("openwireSender", "sender");
        securityConfig.addUser("openwireSender", "SeNdEr");
        //sender cannot receive
        Role senderRole = new Role("sender", true, false, false, false, true, true, false);
        securityConfig.addRole("openwireReceiver", "receiver");
        securityConfig.addUser("openwireReceiver", "ReCeIvEr");
        //receiver cannot send
        Role receiverRole = new Role("receiver", false, true, false, false, true, true, false);
        securityConfig.addRole("openwireGuest", "guest");
        securityConfig.addUser("openwireGuest", "GuEsT");
        //guest cannot do anything
        Role guestRole = new Role("guest", false, false, false, false, false, false, false);
        securityConfig.addRole("openwireDestinationManager", "manager");
        securityConfig.addUser("openwireDestinationManager", "DeStInAtIoN");
        //guest cannot do anything
        Role destRole = new Role("manager", false, false, false, false, true, true, false);
        Map<String, Set<Role>> settings = server.getConfiguration().getSecurityRoles();
        if (settings == null) {
            settings = new HashMap<>();
            server.getConfiguration().setSecurityRoles(settings);
        }
        Set<Role> anySet = settings.get("#");
        if (anySet == null) {
            anySet = new HashSet<>();
            settings.put("#", anySet);
        }
        anySet.add(senderRole);
        anySet.add(receiverRole);
        anySet.add(guestRole);
        anySet.add(destRole);
    }
    Set<TransportConfiguration> acceptors = serverConfig.getAcceptorConfigurations();
    Iterator<TransportConfiguration> iter = acceptors.iterator();
    while (iter.hasNext()) {
        System.out.println("acceptor =>: " + iter.next());
    }
    jmsServer = new JMSServerManagerImpl(server);
    InVMNamingContext namingContext = new InVMNamingContext();
    jmsServer.setRegistry(new JndiBindingRegistry(namingContext));
    jmsServer.start();
    server.start();
    stopped = false;
}

40. MultipliedDelayedMessageTest#initServer()

Project: activemq-artemis
File: MultipliedDelayedMessageTest.java
/**
    * @throws Exception
    */
protected void initServer() throws Exception {
    server = createServer(true, createDefaultInVMConfig());
    server.start();
    // Create settings to enable multiplied redelivery delay
    AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch("*");
    AddressSettings newAddressSettings = new AddressSettings().setRedeliveryDelay(DELAY).setRedeliveryMultiplier(MULTIPLIER).setMaxRedeliveryDelay(MAX_DELAY);
    newAddressSettings.merge(addressSettings);
    server.getAddressSettingsRepository().addMatch(queueName, newAddressSettings);
    locator = createInVMNonHALocator();
}

41. DelayedMessageTest#initServer()

Project: activemq-artemis
File: DelayedMessageTest.java
/**
    * @throws Exception
    */
protected void initServer() throws Exception {
    server = createServer(true, createDefaultInVMConfig());
    server.start();
    AddressSettings qs = server.getAddressSettingsRepository().getMatch("*");
    AddressSettings newSets = new AddressSettings().setRedeliveryDelay(DelayedMessageTest.DELAY);
    newSets.merge(qs);
    server.getAddressSettingsRepository().addMatch(qName, newSets);
    locator = createInVMNonHALocator();
}

42. JMSQueueControlTest#createTestTopicWithDLQ()

Project: activemq-artemis
File: JMSQueueControlTest.java
protected ActiveMQTopic createTestTopicWithDLQ(final String queueName, final ActiveMQQueue dlq) throws Exception {
    serverManager.createTopic(false, queueName);
    ActiveMQTopic testQueue = (ActiveMQTopic) ActiveMQJMSClient.createTopic(queueName);
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setDeadLetterAddress(new SimpleString(dlq.getAddress()));
    addressSettings.setMaxDeliveryAttempts(1);
    server.getAddressSettingsRepository().addMatch(testQueue.getAddress(), addressSettings);
    return testQueue;
}

43. JMSQueueControlTest#createTestQueueWithDLQ()

Project: activemq-artemis
File: JMSQueueControlTest.java
protected ActiveMQQueue createTestQueueWithDLQ(final String queueName, final ActiveMQQueue dlq) throws Exception {
    serverManager.createQueue(false, queueName, null, true, queueName);
    ActiveMQQueue testQueue = (ActiveMQQueue) ActiveMQJMSClient.createQueue(queueName);
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setDeadLetterAddress(new SimpleString(dlq.getAddress()));
    addressSettings.setMaxDeliveryAttempts(1);
    server.getAddressSettingsRepository().addMatch(testQueue.getAddress(), addressSettings);
    return testQueue;
}

44. DeadLetterAddressTest#testDeadLetterAddressWithOverridenSublevelAddressSettings()

Project: activemq-artemis
File: DeadLetterAddressTest.java
@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));
}

45. AddressSettingsTest#test2LevelWordHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void test2LevelWordHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA.toString(), addressSettings);
    repos.addMatch("*", addressSettings2);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA, queueA, false);
    session.createQueue(addressB, queueB, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientProducer cp1 = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    cp1.send(cm);
    cp2.send(cm2);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

46. AddressSettingsTest#test2LevelHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void test2LevelHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA.toString(), addressSettings);
    repos.addMatch("#", addressSettings2);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA, queueA, false);
    session.createQueue(addressB, queueB, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientProducer cp1 = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    cp1.send(cm);
    cp2.send(cm2);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

47. AddressSettingsTest#testSimpleHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testSimpleHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA.toString(), addressSettings);
    repos.addMatch(addressB.toString(), addressSettings2);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA, queueA, false);
    session.createQueue(addressB, queueB, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientProducer cp1 = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    cp1.send(cm);
    cp2.send(cm2);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

48. ConcurrentDeliveryCancelTest#testConcurrentCancels()

Project: activemq-artemis
File: ConcurrentDeliveryCancelTest.java
@Test
@BMRules(rules = { @BMRule(name = "enterCancel-holdThere", targetClass = "org.apache.activemq.artemis.core.server.impl.ServerConsumerImpl", targetMethod = "close", targetLocation = "ENTRY", action = "org.apache.activemq.artemis.tests.extras.byteman.ConcurrentDeliveryCancelTest.enterCancel();") })
public void testConcurrentCancels() throws Exception {
    System.out.println(server.getConfiguration().getJournalLocation().toString());
    server.getAddressSettingsRepository().clear();
    AddressSettings settings = new AddressSettings();
    settings.setMaxDeliveryAttempts(-1);
    server.getAddressSettingsRepository().addMatch("#", settings);
    ActiveMQConnectionFactory cf = ActiveMQJMSClient.createConnectionFactory("tcp://localhost:61616", "test");
    cf.setReconnectAttempts(0);
    cf.setRetryInterval(10);
    System.out.println(".....");
    for (ServerSession srvSess : server.getSessions()) {
        System.out.println(srvSess);
    }
    String queueName = RandomUtil.randomString();
    Queue queue = createQueue(queueName);
    int numberOfMessages = 10000;
    {
        Connection connection = cf.createConnection();
        Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
        MessageProducer producer = session.createProducer(queue);
        for (int i = 0; i < numberOfMessages; i++) {
            TextMessage msg = session.createTextMessage("message " + i);
            msg.setIntProperty("i", i);
            producer.send(msg);
        }
        session.commit();
        connection.close();
    }
    for (int i = 0; i < 100; i++) {
        XAConnectionFactory xacf = ActiveMQJMSClient.createConnectionFactory("tcp://localhost:61616", "test");
        final XAConnection connection = xacf.createXAConnection();
        final XASession theSession = connection.createXASession();
        ((ActiveMQSession) theSession).getCoreSession().addMetaData("theSession", "true");
        connection.start();
        final MessageConsumer consumer = theSession.createConsumer(queue);
        XidImpl xid = newXID();
        theSession.getXAResource().start(xid, XAResource.TMNOFLAGS);
        // I'm setting a small timeout just because I'm lazy to call end myself
        theSession.getXAResource().setTransactionTimeout(1);
        for (int msg = 0; msg < 11; msg++) {
            Assert.assertNotNull(consumer.receiveNoWait());
        }
        System.out.println(".....");
        final List<ServerSession> serverSessions = new LinkedList<>();
        // We will force now the failure simultaneously from several places
        for (ServerSession srvSess : server.getSessions()) {
            if (srvSess.getMetaData("theSession") != null) {
                System.out.println(srvSess);
                serverSessions.add(srvSess);
            }
        }
        // from Transactional reaper
        resetLatches(2);
        List<Thread> threads = new LinkedList<>();
        threads.add(new Thread("ConsumerCloser") {

            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + " closing consumer");
                    consumer.close();
                    System.out.println(Thread.currentThread().getName() + " closed consumer");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        threads.add(new Thread("SessionCloser") {

            @Override
            public void run() {
                for (ServerSession sess : serverSessions) {
                    System.out.println("Thread " + Thread.currentThread().getName() + " starting");
                    try {
                        // A session.close could sneak in through failover or some other scenarios.
                        // a call to RemotingConnection.fail wasn't replicating the issue.
                        // I needed to call Session.close() directly to replicate what was happening in production
                        sess.close(true);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread " + Thread.currentThread().getName() + " done");
                }
            }
        });
        for (Thread t : threads) {
            t.start();
        }
        Assert.assertTrue(latchEnter.await(10, TimeUnit.MINUTES));
        latchFlag.countDown();
        for (Thread t : threads) {
            t.join(5000);
            Assert.assertFalse(t.isAlive());
        }
        connection.close();
    }
    Connection connection = cf.createConnection();
    try {
        connection.setClientID("myID");
        // I am too lazy to call end on all the transactions
        Thread.sleep(5000);
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageConsumer consumer = session.createConsumer(queue);
        HashMap<Integer, AtomicInteger> mapCount = new HashMap<>();
        while (true) {
            TextMessage message = (TextMessage) consumer.receiveNoWait();
            if (message == null) {
                break;
            }
            Integer value = message.getIntProperty("i");
            AtomicInteger count = mapCount.get(value);
            if (count == null) {
                count = new AtomicInteger(0);
                mapCount.put(message.getIntProperty("i"), count);
            }
            count.incrementAndGet();
        }
        boolean failed = false;
        for (int i = 0; i < numberOfMessages; i++) {
            AtomicInteger count = mapCount.get(i);
            if (count == null) {
                System.out.println("Message " + i + " not received");
                failed = true;
            } else if (count.get() > 1) {
                System.out.println("Message " + i + " received " + count.get() + " times");
                failed = true;
            }
        }
        Assert.assertFalse("test failed, look at the system.out of the test for more information", failed);
    } finally {
        connection.close();
    }
}

49. ZeroPrefetchConsumerTest#createArtemisBroker()

Project: activemq-artemis
File: ZeroPrefetchConsumerTest.java
@Override
public EmbeddedJMS createArtemisBroker() throws Exception {
    Configuration config0 = createConfig("localhost", 0);
    String coreQueueAddress = "jms.queue." + brokerZeroQueue.getQueueName();
    AddressSettings addrSettings = new AddressSettings();
    addrSettings.setQueuePrefetch(0);
    config0.getAddressesSettings().put(coreQueueAddress, addrSettings);
    EmbeddedJMS newbroker = new EmbeddedJMS().setConfiguration(config0).setJmsConfiguration(new JMSConfigurationImpl());
    return newbroker;
}

50. StompV12Test#testHeaderRepetitive()

Project: activemq-artemis
File: StompV12Test.java
//test that repetitive headers
@Test
public void testHeaderRepetitive() throws Exception {
    AddressSettings addressSettings = new AddressSettings();
    addressSettings.setAutoCreateJmsQueues(false);
    server.getActiveMQServer().getAddressSettingsRepository().addMatch("#", addressSettings);
    connV12.connect(defUser, defPass);
    ClientStompFrame frame = connV12.createFrame("SEND");
    String body = "Hello World!";
    String cLen = String.valueOf(body.getBytes(StandardCharsets.UTF_8).length);
    frame.addHeader("destination", getQueuePrefix() + getQueueName());
    frame.addHeader("destination", "aNonexistentQueue");
    frame.addHeader("content-type", "application/xml");
    frame.addHeader("content-length", cLen);
    frame.addHeader("foo", "value1");
    frame.addHeader("foo", "value2");
    frame.addHeader("foo", "value3");
    frame.setBody(body);
    connV12.sendFrame(frame);
    //subscribe
    StompClientConnection newConn = StompClientConnectionFactory.createClientConnection("1.2", hostname, port);
    newConn.connect(defUser, defPass);
    ClientStompFrame subFrame = newConn.createFrame("SUBSCRIBE");
    subFrame.addHeader("id", "a-sub");
    subFrame.addHeader("destination", getQueuePrefix() + getQueueName());
    subFrame.addHeader("ack", "auto");
    newConn.sendFrame(subFrame);
    frame = newConn.receiveFrame();
    Assert.assertEquals("MESSAGE", frame.getCommand());
    Assert.assertEquals(body, frame.getBody());
    System.out.println("received: " + frame);
    Assert.assertEquals("value1", frame.getHeader("foo"));
    //unsub
    ClientStompFrame unsubFrame = newConn.createFrame("UNSUBSCRIBE");
    unsubFrame.addHeader("id", "a-sub");
    newConn.disconnect();
    //should get error
    frame = connV12.createFrame("SEND");
    body = "Hello World!";
    cLen = String.valueOf(body.getBytes(StandardCharsets.UTF_8).length);
    frame.addHeader("destination", "aNonexistentQueue");
    frame.addHeader("destination", getQueuePrefix() + getQueueName());
    frame.addHeader("content-type", "application/xml");
    frame.addHeader("content-length", cLen);
    frame.addHeader("receipt", "1234");
    frame.setBody(body);
    ClientStompFrame reply = connV12.sendFrame(frame);
    Assert.assertEquals("ERROR", reply.getCommand());
}

51. PagingTest#testFailMessagesDuplicates()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testFailMessagesDuplicates() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig();
    HashMap<String, AddressSettings> settings = new HashMap<>();
    AddressSettings set = new AddressSettings();
    set.setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL);
    settings.put(PagingTest.ADDRESS.toString(), set);
    server = createServer(true, config, 1024, 5 * 1024, settings);
    server.start();
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = addClientSession(sf.createSession(true, true, 0));
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = session.createMessage(true);
    int biggerMessageSize = 1024;
    byte[] body = new byte[biggerMessageSize];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= biggerMessageSize; j++) {
        bb.put(getSamplebyte(j));
    }
    message.getBodyBuffer().writeBytes(body);
    // Send enough messages to fill up the address.
    producer.send(message);
    producer.send(message);
    producer.send(message);
    Queue q = (Queue) server.getPostOffice().getBinding(ADDRESS).getBindable();
    Assert.assertEquals(3, getMessageCount(q));
    // send a message with a dup ID that should fail b/c the address is full
    SimpleString dupID1 = new SimpleString("abcdefg");
    message.putBytesProperty(Message.HDR_DUPLICATE_DETECTION_ID, dupID1.getData());
    message.putStringProperty("key", dupID1.toString());
    validateExceptionOnSending(producer, message);
    Assert.assertEquals(3, getMessageCount(q));
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    session.start();
    // Receive a message...this should open space for another message
    ClientMessage msgReceived = consumer.receive(5000);
    assertNotNull(msgReceived);
    msgReceived.acknowledge();
    // to make sure it's on the server (roundtrip)
    session.commit();
    consumer.close();
    Assert.assertEquals(2, getMessageCount(q));
    producer.send(message);
    Assert.assertEquals(3, getMessageCount(q));
    consumer = session.createConsumer(ADDRESS);
    for (int i = 0; i < 3; i++) {
        msgReceived = consumer.receive(5000);
        assertNotNull(msgReceived);
        msgReceived.acknowledge();
        session.commit();
    }
}

52. PagingTest#testFailMessagesDurable()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testFailMessagesDurable() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig();
    HashMap<String, AddressSettings> settings = new HashMap<>();
    AddressSettings set = new AddressSettings();
    set.setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL);
    settings.put(PagingTest.ADDRESS.toString(), set);
    server = createServer(true, config, 1024, 5 * 1024, settings);
    server.start();
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true, 0);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = session.createMessage(true);
    int biggerMessageSize = 1024;
    byte[] body = new byte[biggerMessageSize];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= biggerMessageSize; j++) {
        bb.put(getSamplebyte(j));
    }
    message.getBodyBuffer().writeBytes(body);
    // credits to run out.
    for (int i = 0; i < 50; i++) {
        if (i > 2) {
            validateExceptionOnSending(producer, message);
        } else {
            producer.send(message);
        }
    }
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    session.start();
    // Receive a message.. this should release credits
    ClientMessage msgReceived = consumer.receive(5000);
    assertNotNull(msgReceived);
    msgReceived.acknowledge();
    // to make sure it's on the server (roundtrip)
    session.commit();
    boolean exception = false;
    try {
        for (int i = 0; i < 1000; i++) {
            // this send will succeed on the server
            producer.send(message);
        }
    } catch (Exception e) {
        exception = true;
    }
    assertTrue("Expected to throw an exception", exception);
}

53. PagingTest#testPagingDifferentSizes()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testPagingDifferentSizes() throws Exception {
    SimpleString PAGED_ADDRESS_A = new SimpleString("paged-a");
    SimpleString PAGED_ADDRESS_B = new SimpleString("paged-b");
    Configuration configuration = createDefaultInVMConfig();
    Map<String, AddressSettings> addresses = new HashMap<>();
    addresses.put("#", new AddressSettings());
    AddressSettings pagedDestinationA = new AddressSettings().setPageSizeBytes(1024).setMaxSizeBytes(10 * 1024);
    int NUMBER_MESSAGES_BEFORE_PAGING = 11;
    addresses.put(PAGED_ADDRESS_A.toString(), pagedDestinationA);
    AddressSettings pagedDestinationB = new AddressSettings().setPageSizeBytes(2024).setMaxSizeBytes(20 * 1024);
    addresses.put(PAGED_ADDRESS_B.toString(), pagedDestinationB);
    server = createServer(true, configuration, -1, -1, addresses);
    server.start();
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(PAGED_ADDRESS_A, PAGED_ADDRESS_A, true);
    session.createQueue(PAGED_ADDRESS_B, PAGED_ADDRESS_B, true);
    ClientProducer producerA = session.createProducer(PAGED_ADDRESS_A);
    ClientProducer producerB = session.createProducer(PAGED_ADDRESS_B);
    int NUMBER_OF_MESSAGES = 100;
    for (int i = 0; i < NUMBER_MESSAGES_BEFORE_PAGING; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.getBodyBuffer().writeBytes(new byte[896]);
        producerA.send(msg);
        producerB.send(msg);
    }
    // commit was called to clean the buffer only (making sure everything is on the server side)
    session.commit();
    Assert.assertTrue(server.getPagingManager().getPageStore(PAGED_ADDRESS_A).isPaging());
    Assert.assertFalse(server.getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());
    for (int i = 0; i < NUMBER_MESSAGES_BEFORE_PAGING; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.getBodyBuffer().writeBytes(new byte[896]);
        producerA.send(msg);
        producerB.send(msg);
    }
    // commit was called to clean the buffer only (making sure everything is on the server side)
    session.commit();
    Assert.assertTrue(server.getPagingManager().getPageStore(PAGED_ADDRESS_A).isPaging());
    Assert.assertTrue(server.getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());
    for (int i = NUMBER_MESSAGES_BEFORE_PAGING * 2; i < NUMBER_OF_MESSAGES; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.getBodyBuffer().writeBytes(new byte[896]);
        producerA.send(msg);
        producerB.send(msg);
    }
    session.close();
    Assert.assertTrue(server.getPagingManager().getPageStore(PAGED_ADDRESS_A).isPaging());
    Assert.assertTrue(server.getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());
    session = sf.createSession(null, null, false, true, true, false, 0);
    session.start();
    ClientConsumer consumerA = session.createConsumer(PAGED_ADDRESS_A);
    ClientConsumer consumerB = session.createConsumer(PAGED_ADDRESS_B);
    for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
        ClientMessage msg = consumerA.receive(5000);
        Assert.assertNotNull("Couldn't receive a message on consumerA, iteration = " + i, msg);
        msg.acknowledge();
    }
    Assert.assertNull(consumerA.receiveImmediate());
    consumerA.close();
    Assert.assertTrue(server.getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());
    for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
        ClientMessage msg = consumerB.receive(5000);
        Assert.assertNotNull(msg);
        msg.acknowledge();
        session.commit();
    }
    Assert.assertNull(consumerB.receiveImmediate());
    consumerB.close();
    session.close();
}

54. PagingTest#testDropMessagesExpiring()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testDropMessagesExpiring() throws Exception {
    clearDataRecreateServerDirs();
    HashMap<String, AddressSettings> settings = new HashMap<>();
    AddressSettings set = new AddressSettings();
    set.setAddressFullMessagePolicy(AddressFullMessagePolicy.DROP);
    settings.put(PagingTest.ADDRESS.toString(), set);
    server = createServer(true, createDefaultInVMConfig(), 1024, 1024 * 1024, settings);
    server.start();
    final int numberOfMessages = 30000;
    locator.setAckBatchSize(0);
    sf = createSessionFactory(locator);
    ClientSession sessionProducer = sf.createSession();
    sessionProducer.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = sessionProducer.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    ClientSession sessionConsumer = sf.createSession();
    class MyHandler implements MessageHandler {

        int count;

        @Override
        public void onMessage(ClientMessage message1) {
            try {
                Thread.sleep(1);
            } catch (Exception e) {
            }
            count++;
            if (count % 1000 == 0) {
                log.info("received " + count);
            }
            try {
                message1.acknowledge();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    ClientConsumer consumer = sessionConsumer.createConsumer(PagingTest.ADDRESS);
    sessionConsumer.start();
    consumer.setMessageHandler(new MyHandler());
    for (int i = 0; i < numberOfMessages; i++) {
        byte[] body = new byte[1024];
        message = sessionProducer.createMessage(false);
        message.getBodyBuffer().writeBytes(body);
        message.setExpiration(System.currentTimeMillis() + 100);
        producer.send(message);
    }
    sessionProducer.close();
    sessionConsumer.close();
}

55. PagingTest#testDropMessages()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testDropMessages() throws Exception {
    clearDataRecreateServerDirs();
    HashMap<String, AddressSettings> settings = new HashMap<>();
    AddressSettings set = new AddressSettings();
    set.setAddressFullMessagePolicy(AddressFullMessagePolicy.DROP);
    settings.put(PagingTest.ADDRESS.toString(), set);
    server = createServer(true, createDefaultInVMConfig(), 1024, 10 * 1024, settings);
    server.start();
    final int numberOfMessages = 1000;
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(null, null, false, true, true, false, 0);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    for (int i = 0; i < numberOfMessages; i++) {
        byte[] body = new byte[1024];
        message = session.createMessage(true);
        message.getBodyBuffer().writeBytes(body);
        producer.send(message);
    }
    ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);
    session.start();
    for (int i = 0; i < 5; i++) {
        ClientMessage message2 = consumer.receive(PagingTest.RECEIVE_TIMEOUT);
        Assert.assertNotNull(message2);
        message2.acknowledge();
    }
    Assert.assertNull(consumer.receiveImmediate());
    Assert.assertEquals(0, server.getPagingManager().getPageStore(PagingTest.ADDRESS).getAddressSize());
    for (int i = 0; i < numberOfMessages; i++) {
        byte[] body = new byte[1024];
        message = session.createMessage(true);
        message.getBodyBuffer().writeBytes(body);
        producer.send(message);
    }
    for (int i = 0; i < 5; i++) {
        ClientMessage message2 = consumer.receive(PagingTest.RECEIVE_TIMEOUT);
        Assert.assertNotNull(message2);
        message2.acknowledge();
    }
    Assert.assertNull(consumer.receiveImmediate());
    session.close();
    session = sf.createSession(false, true, true);
    producer = session.createProducer(PagingTest.ADDRESS);
    for (int i = 0; i < numberOfMessages; i++) {
        byte[] body = new byte[1024];
        message = session.createMessage(true);
        message.getBodyBuffer().writeBytes(body);
        producer.send(message);
    }
    session.commit();
    consumer = session.createConsumer(PagingTest.ADDRESS);
    session.start();
    for (int i = 0; i < 5; i++) {
        ClientMessage message2 = consumer.receive(PagingTest.RECEIVE_TIMEOUT);
        Assert.assertNotNull(message2);
        message2.acknowledge();
    }
    session.commit();
    Assert.assertNull(consumer.receiveImmediate());
    session.close();
    Assert.assertEquals(0, server.getPagingManager().getPageStore(PagingTest.ADDRESS).getAddressSize());
}

56. LargeMessageTest#internalTestRollbackPartiallyConsumedBuffer()

Project: activemq-artemis
File: LargeMessageTest.java
private void internalTestRollbackPartiallyConsumedBuffer(final boolean redeliveryDelay) throws Exception {
    final int messageSize = largeMessageSize;
    final ClientSession session;
    ActiveMQServer server = createServer(true, isNetty(), storeType);
    AddressSettings settings = new AddressSettings();
    if (redeliveryDelay) {
        settings.setRedeliveryDelay(100);
        if (locator.isCompressLargeMessage()) {
            locator.setConsumerWindowSize(0);
        }
    }
    settings.setMaxDeliveryAttempts(-1);
    server.getAddressSettingsRepository().addMatch("#", settings);
    server.start();
    ClientSessionFactory sf = addSessionFactory(createSessionFactory(locator));
    session = sf.createSession(false, false, false);
    session.createQueue(ADDRESS, ADDRESS, true);
    ClientProducer producer = session.createProducer(ADDRESS);
    for (int i = 0; i < 20; i++) {
        Message clientFile = createLargeClientMessageStreaming(session, messageSize, true);
        clientFile.putIntProperty("value", i);
        producer.send(clientFile);
    }
    session.commit();
    session.start();
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicInteger errors = new AtomicInteger(0);
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    consumer.setMessageHandler(new MessageHandler() {

        int counter = 0;

        @Override
        public void onMessage(ClientMessage message) {
            message.getBodyBuffer().readByte();
            // System.out.println("message:" + message);
            try {
                if (counter++ < 20) {
                    Thread.sleep(100);
                    // System.out.println("Rollback");
                    message.acknowledge();
                    session.rollback();
                } else {
                    message.acknowledge();
                    session.commit();
                }
                if (counter == 40) {
                    latch.countDown();
                }
            } catch (Exception e) {
                latch.countDown();
                e.printStackTrace();
                errors.incrementAndGet();
            }
        }
    });
    assertTrue(latch.await(40, TimeUnit.SECONDS));
    consumer.close();
    session.close();
    validateNoFilesOnLargeDir();
}

57. ExpiryAddressTest#testExpireWithOverridenSublevelAddressSettings()

Project: activemq-artemis
File: ExpiryAddressTest.java
@Test
public void testExpireWithOverridenSublevelAddressSettings() throws Exception {
    SimpleString address = new SimpleString("prefix.address");
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString defaultExpiryAddress = RandomUtil.randomSimpleString();
    SimpleString defaultExpiryQueue = RandomUtil.randomSimpleString();
    SimpleString specificExpiryAddress = RandomUtil.randomSimpleString();
    SimpleString specificExpiryQueue = RandomUtil.randomSimpleString();
    AddressSettings defaultAddressSettings = new AddressSettings().setExpiryAddress(defaultExpiryAddress);
    server.getAddressSettingsRepository().addMatch("prefix.*", defaultAddressSettings);
    AddressSettings specificAddressSettings = new AddressSettings().setExpiryAddress(specificExpiryAddress);
    server.getAddressSettingsRepository().addMatch("prefix.address", specificAddressSettings);
    clientSession.createQueue(address, queue, false);
    clientSession.createQueue(defaultExpiryAddress, defaultExpiryQueue, false);
    clientSession.createQueue(specificExpiryAddress, specificExpiryQueue, false);
    ClientProducer producer = clientSession.createProducer(address);
    ClientMessage clientMessage = createTextMessage(clientSession, "heyho!");
    clientMessage.setExpiration(System.currentTimeMillis());
    producer.send(clientMessage);
    clientSession.start();
    ClientConsumer clientConsumer = clientSession.createConsumer(queue);
    ClientMessage m = clientConsumer.receiveImmediate();
    Assert.assertNull(m);
    clientConsumer.close();
    clientConsumer = clientSession.createConsumer(defaultExpiryQueue);
    m = clientConsumer.receiveImmediate();
    Assert.assertNull(m);
    clientConsumer.close();
    clientConsumer = clientSession.createConsumer(specificExpiryQueue);
    m = clientConsumer.receive(500);
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
    m.acknowledge();
}

58. QueueImplTest#testTotalIteratorOrder()

Project: activemq-artemis
File: QueueImplTest.java
@Test
public void testTotalIteratorOrder() throws Exception {
    final String MY_ADDRESS = "myAddress";
    final String MY_QUEUE = "myQueue";
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(createDefaultInVMConfig(), true));
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    ClientSessionFactory factory = createSessionFactory(locator);
    ClientSession session = addClientSession(factory.createSession(false, true, true));
    session.createQueue(MY_ADDRESS, MY_QUEUE, true);
    ClientProducer producer = addClientProducer(session.createProducer(MY_ADDRESS));
    for (int i = 0; i < 50; i++) {
        ClientMessage message = session.createMessage(true);
        message.getBodyBuffer().writeBytes(new byte[1024]);
        message.putIntProperty("order", i);
        producer.send(message);
    }
    producer.close();
    session.close();
    factory.close();
    locator.close();
    Queue queue = ((LocalQueueBinding) server.getPostOffice().getBinding(new SimpleString(MY_QUEUE))).getQueue();
    LinkedListIterator<MessageReference> totalIterator = queue.totalIterator();
    try {
        int i = 0;
        while (totalIterator.hasNext()) {
            MessageReference ref = totalIterator.next();
            Assert.assertEquals(i++, ref.getMessage().getIntProperty("order").intValue());
        }
    } finally {
        totalIterator.close();
        server.stop();
    }
}

59. PagingStoreImplTest#testOrderOnPaging()

Project: activemq-artemis
File: PagingStoreImplTest.java
@Test
public void testOrderOnPaging() throws Throwable {
    clearDataRecreateServerDirs();
    SequentialFileFactory factory = new NIOSequentialFileFactory(new File(getPageDir()), 1);
    PagingStoreFactory storeFactory = new FakeStoreFactory(factory);
    final int MAX_SIZE = 1024 * 10;
    AddressSettings settings = new AddressSettings().setPageSizeBytes(MAX_SIZE).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    final PagingStore store = new PagingStoreImpl(PagingStoreImplTest.destinationTestName, null, 100, createMockManager(), createStorageManagerMock(), factory, storeFactory, new SimpleString("test"), settings, getExecutorFactory().getExecutor(), false);
    store.start();
    Assert.assertEquals(0, store.getNumberOfPages());
    // Marked the store to be paged
    store.startPaging();
    final CountDownLatch producedLatch = new CountDownLatch(1);
    Assert.assertEquals(1, store.getNumberOfPages());
    final SimpleString destination = new SimpleString("test");
    final long NUMBER_OF_MESSAGES = 100000;
    final List<Throwable> errors = new ArrayList<>();
    class WriterThread extends Thread {

        WriterThread() {
            super("PageWriter");
        }

        @Override
        public void run() {
            try {
                for (long i = 0; i < NUMBER_OF_MESSAGES; i++) {
                    // Each thread will Keep paging until all the messages are depaged.
                    // This is possible because the depage thread is not actually reading the pages.
                    // Just using the internal API to remove it from the page file system
                    ServerMessage msg = createMessage(i, store, destination, createRandomBuffer(i, 1024));
                    msg.putLongProperty("count", i);
                    final RoutingContextImpl ctx2 = new RoutingContextImpl(null);
                    while (!store.page(msg, ctx2.getTransaction(), ctx2.getContextListing(store.getStoreName()), lock)) {
                        store.startPaging();
                    }
                    if (i == 0) {
                        producedLatch.countDown();
                    }
                }
            } catch (Throwable e) {
                e.printStackTrace();
                errors.add(e);
            }
        }
    }
    class ReaderThread extends Thread {

        ReaderThread() {
            super("PageReader");
        }

        @Override
        public void run() {
            try {
                long msgsRead = 0;
                while (msgsRead < NUMBER_OF_MESSAGES) {
                    Page page = store.depage();
                    if (page != null) {
                        page.open();
                        List<PagedMessage> messages = page.read(new NullStorageManager());
                        for (PagedMessage pgmsg : messages) {
                            ServerMessage msg = pgmsg.getMessage();
                            Assert.assertEquals(msgsRead++, msg.getMessageID());
                            Assert.assertEquals(msg.getMessageID(), msg.getLongProperty("count").longValue());
                        }
                        page.close();
                        page.delete(null);
                    } else {
                        System.out.println("Depaged!!!! numerOfMessages = " + msgsRead + " of " + NUMBER_OF_MESSAGES);
                        Thread.sleep(500);
                    }
                }
            } catch (Throwable e) {
                e.printStackTrace();
                errors.add(e);
            }
        }
    }
    WriterThread producerThread = new WriterThread();
    producerThread.start();
    ReaderThread consumer = new ReaderThread();
    consumer.start();
    producerThread.join();
    consumer.join();
    store.stop();
    for (Throwable e : errors) {
        throw e;
    }
}

60. PagingStoreImplTest#testRestartPage()

Project: activemq-artemis
File: PagingStoreImplTest.java
@Test
public void testRestartPage() throws Throwable {
    clearDataRecreateServerDirs();
    SequentialFileFactory factory = new NIOSequentialFileFactory(new File(getPageDir()), 1);
    PagingStoreFactory storeFactory = new FakeStoreFactory(factory);
    final int MAX_SIZE = 1024 * 10;
    AddressSettings settings = new AddressSettings().setPageSizeBytes(MAX_SIZE).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    final PagingStore storeImpl = new PagingStoreImpl(PagingStoreImplTest.destinationTestName, null, 100, createMockManager(), createStorageManagerMock(), factory, storeFactory, new SimpleString("test"), settings, getExecutorFactory().getExecutor(), true);
    storeImpl.start();
    Assert.assertEquals(0, storeImpl.getNumberOfPages());
    // Marked the store to be paged
    storeImpl.startPaging();
    storeImpl.depage();
    Assert.assertNull(storeImpl.getCurrentPage());
    storeImpl.startPaging();
    Assert.assertNotNull(storeImpl.getCurrentPage());
    storeImpl.stop();
}

61. PagingStoreImplTest#testStore()

Project: activemq-artemis
File: PagingStoreImplTest.java
@Test
public void testStore() throws Exception {
    SequentialFileFactory factory = new FakeSequentialFileFactory();
    PagingStoreFactory storeFactory = new FakeStoreFactory(factory);
    AddressSettings addressSettings = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    PagingStore storeImpl = new PagingStoreImpl(PagingStoreImplTest.destinationTestName, null, 100, createMockManager(), createStorageManagerMock(), factory, storeFactory, PagingStoreImplTest.destinationTestName, addressSettings, getExecutorFactory().getExecutor(), true);
    storeImpl.start();
    Assert.assertEquals(0, storeImpl.getNumberOfPages());
    storeImpl.startPaging();
    Assert.assertEquals(1, storeImpl.getNumberOfPages());
    List<ActiveMQBuffer> buffers = new ArrayList<>();
    ActiveMQBuffer buffer = createRandomBuffer(0, 10);
    buffers.add(buffer);
    SimpleString destination = new SimpleString("test");
    ServerMessage msg = createMessage(1, storeImpl, destination, buffer);
    Assert.assertTrue(storeImpl.isPaging());
    final RoutingContextImpl ctx = new RoutingContextImpl(null);
    Assert.assertTrue(storeImpl.page(msg, ctx.getTransaction(), ctx.getContextListing(storeImpl.getStoreName()), lock));
    Assert.assertEquals(1, storeImpl.getNumberOfPages());
    storeImpl.sync();
    storeImpl = new PagingStoreImpl(PagingStoreImplTest.destinationTestName, null, 100, createMockManager(), createStorageManagerMock(), factory, storeFactory, PagingStoreImplTest.destinationTestName, addressSettings, getExecutorFactory().getExecutor(), true);
    storeImpl.start();
    Assert.assertEquals(1, storeImpl.getNumberOfPages());
}

62. PageStressTest#testPageOnMultipleDestinations()

Project: activemq-artemis
File: PageStressTest.java
@Test
public void testPageOnMultipleDestinations() throws Exception {
    HashMap<String, AddressSettings> settings = new HashMap<>();
    AddressSettings setting = new AddressSettings().setMaxSizeBytes(20 * 1024 * 1024);
    settings.put("page-adr", setting);
    server = addServer(createServer(true, createDefaultInVMConfig(), 10 * 1024 * 1024, 20 * 1024 * 1024, settings));
    server.start();
    ClientSessionFactory factory = createSessionFactory(locator);
    ClientSession session = null;
    session = factory.createSession(false, false, false);
    SimpleString address = new SimpleString("page-adr");
    SimpleString[] queue = new SimpleString[] { new SimpleString("queue1"), new SimpleString("queue2") };
    session.createQueue(address, queue[0], null, true);
    session.createQueue(address, queue[1], null, true);
    ClientProducer prod = session.createProducer(address);
    ClientMessage message = createBytesMessage(session, ActiveMQBytesMessage.TYPE, new byte[700], false);
    int NUMBER_OF_MESSAGES = 60000;
    for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
        if (i % 10000 == 0) {
            System.out.println(i);
        }
        prod.send(message);
    }
    session.commit();
    session.start();
    int[] counters = new int[2];
    ClientConsumer[] consumers = new ClientConsumer[] { session.createConsumer(queue[0]), session.createConsumer(queue[1]) };
    while (true) {
        int msgs1 = readMessages(session, consumers[0], queue[0]);
        int msgs2 = readMessages(session, consumers[1], queue[1]);
        counters[0] += msgs1;
        counters[1] += msgs2;
        System.out.println("msgs1 = " + msgs1 + " msgs2 = " + msgs2);
        if (msgs1 + msgs2 == 0) {
            break;
        }
    }
    consumers[0].close();
    consumers[1].close();
    Assert.assertEquals(NUMBER_OF_MESSAGES, counters[0]);
    Assert.assertEquals(NUMBER_OF_MESSAGES, counters[1]);
}

63. PageStressTest#testStopDuringDepage()

Project: activemq-artemis
File: PageStressTest.java
@Test
public void testStopDuringDepage() throws Exception {
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false).setJournalSyncTransactional(false);
    HashMap<String, AddressSettings> settings = new HashMap<>();
    AddressSettings setting = new AddressSettings().setMaxSizeBytes(20 * 1024 * 1024);
    settings.put("page-adr", setting);
    server = addServer(createServer(true, config, 10 * 1024 * 1024, 20 * 1024 * 1024, settings));
    server.start();
    final int NUMBER_OF_MESSAGES = 60000;
    ClientSessionFactory factory = createSessionFactory(locator);
    ClientSession session = addClientSession(factory.createSession(null, null, false, false, true, false, 1024 * NUMBER_OF_MESSAGES));
    SimpleString address = new SimpleString("page-adr");
    session.createQueue(address, address, null, true);
    ClientProducer prod = session.createProducer(address);
    ClientMessage message = createBytesMessage(session, ActiveMQBytesMessage.TYPE, new byte[700], true);
    for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
        if (i % 10000 == 0) {
            System.out.println("Sent " + i);
        }
        prod.send(message);
    }
    session.commit();
    session.start();
    ClientConsumer consumer = session.createConsumer(address);
    int msgs = 0;
    ClientMessage msg;
    do {
        msg = consumer.receive(10000);
        if (msg != null) {
            msg.acknowledge();
            if (++msgs % 1000 == 0) {
                System.out.println("Received " + msgs);
            }
        }
    } while (msg != null);
    session.commit();
    session.close();
    server.stop();
    System.out.println("server stopped, nr msgs: " + msgs);
    server = addServer(createServer(true, config, 10 * 1024 * 1024, 20 * 1024 * 1024, settings));
    server.start();
    factory = createSessionFactory(locator);
    session = addClientSession(factory.createSession(false, false, false));
    consumer = session.createConsumer(address);
    session.start();
    do {
        msg = consumer.receive(10000);
        if (msg != null) {
            msg.acknowledge();
            session.commit();
            if (++msgs % 1000 == 0) {
                System.out.println("Received " + msgs);
            }
        }
    } while (msg != null);
    System.out.println("msgs second time: " + msgs);
    Assert.assertEquals(NUMBER_OF_MESSAGES, msgs);
}

64. BasicXaRecoveryTest#testRollbackPaging()

Project: activemq-artemis
File: BasicXaRecoveryTest.java
public void testRollbackPaging(final boolean restartServer) throws Exception {
    Xid xid = new XidImpl("xa1".getBytes(), 1, UUIDGenerator.getInstance().generateStringUUID().getBytes());
    SimpleString pageQueue = new SimpleString("pagequeue");
    AddressSettings pageAddressSettings = new AddressSettings().setMaxSizeBytes(100 * 1024).setPageSizeBytes(10 * 1024);
    addressSettings.put(pageQueue.toString(), pageAddressSettings);
    addSettings();
    clientSession.createQueue(pageQueue, pageQueue, null, true);
    clientSession.start(xid, XAResource.TMNOFLAGS);
    ClientProducer pageProducer = clientSession.createProducer(pageQueue);
    for (int i = 0; i < 1000; i++) {
        ClientMessage m = createBytesMessage(new byte[512], true);
        pageProducer.send(m);
    }
    clientSession.end(xid, XAResource.TMSUCCESS);
    clientSession.prepare(xid);
    if (restartServer) {
        stopAndRestartServer();
    } else {
        recreateClients();
    }
    Xid[] xids = clientSession.recover(XAResource.TMSTARTRSCAN);
    Assert.assertEquals(1, xids.length);
    Assert.assertEquals(xids[0].getFormatId(), xid.getFormatId());
    ActiveMQTestBase.assertEqualsByteArrays(xids[0].getBranchQualifier(), xid.getBranchQualifier());
    ActiveMQTestBase.assertEqualsByteArrays(xids[0].getGlobalTransactionId(), xid.getGlobalTransactionId());
    clientSession.rollback(xid);
    clientSession.start();
    ClientConsumer pageConsumer = clientSession.createConsumer(pageQueue);
    Assert.assertNull(pageConsumer.receiveImmediate());
// Management message (from createQueue) will not be taken into account again as it is nonPersistent
}

65. BasicXaRecoveryTest#verifyPaging()

Project: activemq-artemis
File: BasicXaRecoveryTest.java
public void verifyPaging(final boolean restartServer) throws Exception {
    if (storeType == StoreConfiguration.StoreType.DATABASE)
        return;
    Xid xid = new XidImpl("xa1".getBytes(), 1, UUIDGenerator.getInstance().generateStringUUID().getBytes());
    SimpleString pageQueue = new SimpleString("pagequeue");
    AddressSettings pageAddressSettings = new AddressSettings().setMaxSizeBytes(100 * 1024).setPageSizeBytes(10 * 1024);
    addressSettings.put(pageQueue.toString(), pageAddressSettings);
    addSettings();
    clientSession.createQueue(pageQueue, pageQueue, null, true);
    clientSession.start(xid, XAResource.TMNOFLAGS);
    ClientProducer pageProducer = clientSession.createProducer(pageQueue);
    for (int i = 0; i < 1000; i++) {
        ClientMessage m = createBytesMessage(new byte[512], true);
        pageProducer.send(m);
    }
    pageProducer.close();
    clientSession.end(xid, XAResource.TMSUCCESS);
    clientSession.prepare(xid);
    BasicXaRecoveryTest.log.info("*** stopping and restarting");
    if (restartServer) {
        stopAndRestartServer();
    } else {
        recreateClients();
    }
    Xid[] xids = clientSession.recover(XAResource.TMSTARTRSCAN);
    Assert.assertEquals(xids.length, 1);
    Assert.assertEquals(xids[0].getFormatId(), xid.getFormatId());
    ActiveMQTestBase.assertEqualsByteArrays(xids[0].getBranchQualifier(), xid.getBranchQualifier());
    ActiveMQTestBase.assertEqualsByteArrays(xids[0].getGlobalTransactionId(), xid.getGlobalTransactionId());
    clientSession.commit(xid, false);
    clientSession.close();
    clientSession = sessionFactory.createSession(false, false, false);
    clientSession.start();
    ClientConsumer pageConsumer = clientSession.createConsumer(pageQueue);
    for (int i = 0; i < 1000; i++) {
        ClientMessage m = pageConsumer.receive(10000);
        Assert.assertNotNull(m);
        m.acknowledge();
        clientSession.commit();
    }
    Assert.assertNull(pageConsumer.receiveImmediate());
}

66. ScaleDownTest#testOrderWithPaging()

Project: activemq-artemis
File: ScaleDownTest.java
@Test
public void testOrderWithPaging() throws Exception {
    final int CHUNK_SIZE = 50;
    int messageCount = 0;
    final String addressName = "testAddress";
    final String queueName = "testQueue";
    createQueue(0, addressName, queueName, null, false);
    createQueue(1, addressName, queueName, null, false);
    ClientSessionFactory sf = sfs[0];
    ClientSession session = addClientSession(sf.createSession(false, false));
    ClientProducer producer = addClientProducer(session.createProducer(addressName));
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    servers[0].getAddressSettingsRepository().addMatch("#", defaultSetting);
    while (!servers[0].getPagingManager().getPageStore(new SimpleString(addressName)).isPaging()) {
        for (int i = 0; i < CHUNK_SIZE; i++) {
            Message message = session.createMessage(true);
            message.getBodyBuffer().writeBytes(new byte[1024]);
            message.putIntProperty("order", i);
            producer.send(message);
            messageCount++;
        }
        session.commit();
    }
    servers[0].stop();
    addConsumer(0, 1, queueName, null);
    for (int i = 0; i < messageCount; i++) {
        Assert.assertEquals(i, consumers[0].getConsumer().receive(250).getIntProperty("order").intValue());
    }
    Assert.assertNull(consumers[0].getConsumer().receive(250));
    removeConsumer(0);
}

67. ScaleDownTest#testPaging()

Project: activemq-artemis
File: ScaleDownTest.java
@Test
public void testPaging() throws Exception {
    final int CHUNK_SIZE = 50;
    int messageCount = 0;
    final String addressName = "testAddress";
    final String queueName = "testQueue";
    createQueue(0, addressName, queueName, null, false);
    createQueue(1, addressName, queueName, null, false);
    ClientSessionFactory sf = sfs[0];
    ClientSession session = addClientSession(sf.createSession(false, false));
    ClientProducer producer = addClientProducer(session.createProducer(addressName));
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    servers[0].getAddressSettingsRepository().addMatch("#", defaultSetting);
    while (!servers[0].getPagingManager().getPageStore(new SimpleString(addressName)).isPaging()) {
        for (int i = 0; i < CHUNK_SIZE; i++) {
            Message message = session.createMessage(true);
            message.getBodyBuffer().writeBytes(new byte[1024]);
            producer.send(message);
            messageCount++;
        }
        session.commit();
    }
    servers[0].stop();
    addConsumer(0, 1, queueName, null);
    for (int i = 0; i < messageCount; i++) {
        Assert.assertNotNull(consumers[0].getConsumer().receive(250));
    }
    Assert.assertNull(consumers[0].getConsumer().receive(250));
    removeConsumer(0);
}

68. ScaleDownDirectTest#testPaging()

Project: activemq-artemis
File: ScaleDownDirectTest.java
@Test
public void testPaging() throws Exception {
    final int CHUNK_SIZE = 50;
    int messageCount = 0;
    final String addressName = "testAddress";
    final String queueName = "testQueue";
    createQueue(0, addressName, queueName, null, true);
    createQueue(1, addressName, queueName, null, true);
    ClientSessionFactory sf = sfs[0];
    ClientSession session = addClientSession(sf.createSession(false, false));
    ClientProducer producer = addClientProducer(session.createProducer(addressName));
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    servers[0].getAddressSettingsRepository().addMatch("#", defaultSetting);
    while (!servers[0].getPagingManager().getPageStore(new SimpleString(addressName)).isPaging()) {
        for (int i = 0; i < CHUNK_SIZE; i++) {
            Message message = session.createMessage(true);
            message.getBodyBuffer().writeBytes(new byte[1024]);
            // The only purpose of this count here is for eventually debug messages on print-data / print-pages
            //            message.putIntProperty("count", messageCount);
            producer.send(message);
            messageCount++;
        }
        session.commit();
    }
    assertEquals(messageCount, performScaledown());
    servers[0].stop();
    addConsumer(0, 1, queueName, null);
    for (int i = 0; i < messageCount; i++) {
        ClientMessage message = consumers[0].getConsumer().receive(500);
        Assert.assertNotNull(message);
    //         Assert.assertEquals(i, message.getIntProperty("count").intValue());
    }
    Assert.assertNull(consumers[0].getConsumer().receiveImmediate());
    removeConsumer(0);
}

69. ScaleDown3NodeTest#testBasicScaleDownInternal()

Project: activemq-artemis
File: ScaleDown3NodeTest.java
private void testBasicScaleDownInternal(int reconnectAttempts, boolean large) throws Exception {
    AddressSettings addressSettings = new AddressSettings().setRedistributionDelay(0);
    servers[0].getAddressSettingsRepository().addMatch("#", addressSettings);
    servers[1].getAddressSettingsRepository().addMatch("#", addressSettings);
    servers[2].getAddressSettingsRepository().addMatch("#", addressSettings);
    servers[0].getConfiguration().getClusterConfigurations().get(0).setReconnectAttempts(reconnectAttempts);
    servers[1].getConfiguration().getClusterConfigurations().get(0).setReconnectAttempts(reconnectAttempts);
    servers[2].getConfiguration().getClusterConfigurations().get(0).setReconnectAttempts(reconnectAttempts);
    final int TEST_SIZE = 10;
    final String addressName = "testAddress";
    final String queueName1 = "testQueue1";
    // create a queue on each node mapped to the same address
    createQueue(0, addressName, queueName1, null, false, servers[0].getConfiguration().getClusterUser(), servers[0].getConfiguration().getClusterPassword());
    createQueue(1, addressName, queueName1, null, false, servers[1].getConfiguration().getClusterUser(), servers[1].getConfiguration().getClusterPassword());
    createQueue(2, addressName, queueName1, null, false, servers[2].getConfiguration().getClusterUser(), servers[2].getConfiguration().getClusterPassword());
    // pause the SnF queue so that when the server tries to redistribute a message it won't actually go across the cluster bridge
    String snfAddress = "sf.cluster0." + servers[0].getNodeID().toString();
    Queue snfQueue = ((LocalQueueBinding) servers[2].getPostOffice().getBinding(SimpleString.toSimpleString(snfAddress))).getQueue();
    snfQueue.pause();
    ClientSession session = sfs[2].createSession(servers[2].getConfiguration().getClusterUser(), servers[2].getConfiguration().getClusterPassword(), false, true, false, false, 0);
    Message message;
    if (large) {
        LargeServerMessageImpl fileMessage = new LargeServerMessageImpl((JournalStorageManager) servers[2].getStorageManager());
        fileMessage.setMessageID(1005);
        fileMessage.setDurable(true);
        for (int i = 0; i < 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE; i++) {
            fileMessage.addBytes(new byte[] { ActiveMQTestBase.getSamplebyte(i) });
        }
        fileMessage.putLongProperty(Message.HDR_LARGE_BODY_SIZE, 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);
        fileMessage.releaseResources();
        message = fileMessage;
    } else {
        message = session.createMessage(false);
    }
    for (int i = 0; i < TEST_SIZE; i++) {
        ClientProducer producer = session.createProducer(addressName);
        producer.send(message);
    }
    if (large) {
        ((LargeServerMessageImpl) message).deleteFile();
    }
    // add a consumer to node 0 to trigger redistribution here
    addConsumer(0, 0, queueName1, null, true, servers[0].getConfiguration().getClusterUser(), servers[0].getConfiguration().getClusterPassword());
    // allow some time for redistribution to move the message to the SnF queue
    long timeout = 10000;
    long start = System.currentTimeMillis();
    long messageCount = 0;
    while (System.currentTimeMillis() - start < timeout) {
        // ensure the message is not in the queue on node 2
        messageCount = getMessageCount(snfQueue);
        if (messageCount < TEST_SIZE) {
            Thread.sleep(200);
        } else {
            break;
        }
    }
    // ensure the message is in the SnF queue
    Assert.assertEquals(TEST_SIZE, getMessageCount(snfQueue));
    // trigger scaleDown from node 0 to node 1
    IntegrationTestLogger.LOGGER.info("============ Stopping " + servers[0].getNodeID());
    removeConsumer(0);
    servers[0].stop();
    start = System.currentTimeMillis();
    while (System.currentTimeMillis() - start < timeout) {
        // ensure the message is not in the queue on node 2
        messageCount = getMessageCount(((LocalQueueBinding) servers[2].getPostOffice().getBinding(new SimpleString(queueName1))).getQueue());
        if (messageCount > 0) {
            Thread.sleep(200);
        } else {
            break;
        }
    }
    Assert.assertEquals(0, messageCount);
    // get the messages from queue 1 on node 1
    addConsumer(0, 1, queueName1, null, true, servers[1].getConfiguration().getClusterUser(), servers[1].getConfiguration().getClusterPassword());
    // allow some time for redistribution to move the message to node 1
    start = System.currentTimeMillis();
    while (System.currentTimeMillis() - start < timeout) {
        // ensure the message is not in the queue on node 2
        messageCount = getMessageCount(((LocalQueueBinding) servers[1].getPostOffice().getBinding(new SimpleString(queueName1))).getQueue());
        if (messageCount < TEST_SIZE) {
            Thread.sleep(200);
        } else {
            break;
        }
    }
    // ensure the message is in queue 1 on node 1 as expected
    Assert.assertEquals(TEST_SIZE, messageCount);
    for (int i = 0; i < TEST_SIZE; i++) {
        ClientMessage clientMessage = consumers[0].getConsumer().receive(250);
        Assert.assertNotNull(clientMessage);
        if (large) {
            Assert.assertEquals(2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE, clientMessage.getBodySize());
            for (int j = 0; j < 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE; j++) {
                Assert.assertEquals(ActiveMQTestBase.getSamplebyte(j), clientMessage.getBodyBuffer().readByte());
            }
        }
        IntegrationTestLogger.LOGGER.info("Received: " + clientMessage);
        clientMessage.acknowledge();
    }
    // ensure there are no more messages on queue 1
    ClientMessage clientMessage = consumers[0].getConsumer().receive(250);
    Assert.assertNull(clientMessage);
    removeConsumer(0);
}

70. ExpiryRunnerTest#testExpireToExpiryQueue()

Project: activemq-artemis
File: ExpiryRunnerTest.java
@Test
public void testExpireToExpiryQueue() throws Exception {
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(expiryAddress);
    server.getAddressSettingsRepository().addMatch(qName2.toString(), addressSettings);
    clientSession.deleteQueue(qName);
    clientSession.createQueue(qName, qName, null, false);
    clientSession.createQueue(qName, qName2, null, false);
    ClientProducer producer = clientSession.createProducer(qName);
    int numMessages = 100;
    long expiration = System.currentTimeMillis();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage m = createTextMessage(clientSession, "m" + i);
        m.setExpiration(expiration);
        producer.send(m);
    }
    Thread.sleep(1600);
    Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(qName).getBindable()).getMessageCount());
    Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(qName).getBindable()).getDeliveringCount());
    ClientConsumer consumer = clientSession.createConsumer(expiryQueue);
    clientSession.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = consumer.receive(500);
        Assert.assertNotNull(cm);
    // assertEquals("m" + i, cm.getBody().getString());
    }
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = consumer.receive(500);
        Assert.assertNotNull(cm);
    // assertEquals("m" + i, cm.getBody().getString());
    }
    consumer.close();
}

71. AddressFullLoggingTest#testBlockLogging()

Project: activemq-artemis
File: AddressFullLoggingTest.java
@Test
public /**
    * When running this test from an IDE add this to the test command line so that the AssertionLoggerHandler works properly:
    *
    *   -Djava.util.logging.manager=org.jboss.logmanager.LogManager  -Dlogging.configuration=file:<path_to_source>/tests/config/logging.properties
    */
void testBlockLogging() throws Exception {
    final int MAX_MESSAGES = 200;
    final String MY_ADDRESS = "myAddress";
    final String MY_QUEUE = "myQueue";
    ActiveMQServer server = createServer(false);
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024).setAddressFullMessagePolicy(AddressFullMessagePolicy.BLOCK);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    ClientSessionFactory factory = createSessionFactory(locator);
    ClientSession session = factory.createSession(false, true, true);
    session.createQueue(MY_ADDRESS, MY_QUEUE, true);
    final ClientProducer producer = session.createProducer(MY_ADDRESS);
    final ClientMessage message = session.createMessage(false);
    message.getBodyBuffer().writeBytes(new byte[1024]);
    ExecutorService executor = Executors.newFixedThreadPool(1, ActiveMQThreadFactory.defaultThreadFactory());
    Callable<Object> sendMessageTask = new Callable<Object>() {

        @Override
        public Object call() throws ActiveMQException {
            producer.send(message);
            return null;
        }
    };
    int sendCount = 0;
    for (int i = 0; i < MAX_MESSAGES; i++) {
        Future<Object> future = executor.submit(sendMessageTask);
        try {
            future.get(3, TimeUnit.SECONDS);
            sendCount++;
        } catch (TimeoutException ex) {
            break;
        } finally {
            // may or may not desire this
            future.cancel(true);
        }
    }
    executor.shutdown();
    session.close();
    session = factory.createSession(false, true, true);
    session.start();
    ClientConsumer consumer = session.createConsumer(MY_QUEUE);
    for (int i = 0; i < sendCount; i++) {
        ClientMessage msg = consumer.receive(250);
        if (msg == null)
            break;
        msg.acknowledge();
    }
    session.close();
    locator.close();
    server.stop();
    // Using the code only so the test doesn't fail just because someone edits the log text
    Assert.assertTrue("Expected to find AMQ222183", AssertionLoggerHandler.findText("AMQ222183", "myAddress"));
    Assert.assertTrue("Expected to find AMQ221046", AssertionLoggerHandler.findText("AMQ221046", "myAddress"));
}

72. ScheduledMessageTest#testRedeliveryAfterPrepare()

Project: activemq-artemis
File: ScheduledMessageTest.java
@Test
public void testRedeliveryAfterPrepare() throws Exception {
    AddressSettings qs = new AddressSettings().setRedeliveryDelay(5000L);
    server.getAddressSettingsRepository().addMatch(atestq.toString(), qs);
    ClientSessionFactory sessionFactory = createSessionFactory(locator);
    ClientSession session = sessionFactory.createSession(false, false, false);
    session.createQueue(atestq, atestq, true);
    ClientProducer producer = session.createProducer(atestq);
    for (int i = 0; i < 100; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.putIntProperty("key", i);
        producer.send(msg);
        session.commit();
    }
    session.close();
    session = sessionFactory.createSession(true, false, false);
    ClientConsumer consumer = session.createConsumer(atestq);
    ArrayList<Xid> xids = new ArrayList<>();
    session.start();
    for (int i = 0; i < 100; i++) {
        Xid xid = newXID();
        session.start(xid, XAResource.TMNOFLAGS);
        ClientMessage msg = consumer.receive(5000);
        assertNotNull(msg);
        msg.acknowledge();
        session.end(xid, XAResource.TMSUCCESS);
        session.prepare(xid);
        xids.add(xid);
    }
    session.rollback(xids.get(0));
    xids.set(0, null);
    session.close();
    server.stop();
    configuration = createDefaultInVMConfig().addAddressesSetting(atestq.toString(), qs);
    server = createServer(true, configuration);
    server.start();
    locator = createInVMNonHALocator();
    final AtomicInteger count = new AtomicInteger(0);
    Thread t = new Thread() {

        @Override
        public void run() {
            try {
                ClientSessionFactory sf = createSessionFactory(locator);
                ClientSession session = sf.createSession(false, false);
                session.start();
                ClientConsumer cons = session.createConsumer(atestq);
                for (int i = 0; i < 100; i++) {
                    ClientMessage msg = cons.receive(100000);
                    assertNotNull(msg);
                    count.incrementAndGet();
                    msg.acknowledge();
                    session.commit();
                }
                session.close();
                sf.close();
            } catch (Throwable e) {
                e.printStackTrace();
                count.set(-1);
            }
        }
    };
    t.start();
    sessionFactory = createSessionFactory(locator);
    session = sessionFactory.createSession(true, false, false);
    for (Xid xid : xids) {
        if (xid != null) {
            session.rollback(xid);
        }
    }
    session.close();
    t.join();
    assertEquals(100, count.get());
}

73. ScheduledMessageTest#testPagedMessageDeliveredMultipleConsumersAfterRecoverCorrectly()

Project: activemq-artemis
File: ScheduledMessageTest.java
@Test
public void testPagedMessageDeliveredMultipleConsumersAfterRecoverCorrectly() throws Exception {
    AddressSettings qs = new AddressSettings().setRedeliveryDelay(5000L);
    server.getAddressSettingsRepository().addMatch(atestq.toString(), qs);
    // then we create a client as normal
    ClientSessionFactory sessionFactory = createSessionFactory(locator);
    ClientSession session = sessionFactory.createSession(false, true, false);
    session.createQueue(atestq, atestq, null, true);
    session.createQueue(atestq, atestq2, null, true);
    ClientProducer producer = session.createProducer(atestq);
    ClientMessage message = createDurableMessage(session, "m1");
    producer.send(message);
    producer.close();
    ClientConsumer consumer = session.createConsumer(atestq);
    ClientConsumer consumer2 = session.createConsumer(atestq2);
    session.start();
    ClientMessage message3 = consumer.receive(1000);
    Assert.assertNotNull(message3);
    message3.acknowledge();
    ClientMessage message2 = consumer2.receive(1000);
    Assert.assertNotNull(message2);
    message2.acknowledge();
    Assert.assertEquals("m1", message3.getBodyBuffer().readString());
    Assert.assertEquals("m1", message2.getBodyBuffer().readString());
    long time = System.currentTimeMillis();
    // force redelivery
    consumer.close();
    consumer2.close();
    session.rollback();
    producer.close();
    session.close();
    server.stop();
    server = null;
    server = createServer(true, configuration);
    server.start();
    sessionFactory = createSessionFactory(locator);
    session = sessionFactory.createSession(false, true, true);
    consumer = session.createConsumer(atestq);
    consumer2 = session.createConsumer(atestq2);
    session.start();
    message3 = consumer.receive(5250);
    Assert.assertNotNull(message3);
    message2 = consumer2.receive(1000);
    Assert.assertNotNull(message2);
    time += 5000;
    Assert.assertTrue(System.currentTimeMillis() >= time);
    Assert.assertEquals("m1", message3.getBodyBuffer().readString());
    Assert.assertEquals("m1", message2.getBodyBuffer().readString());
    message2.acknowledge();
    message3.acknowledge();
    // Make sure no more messages
    consumer.close();
    consumer2.close();
    consumer = session.createConsumer(atestq);
    Assert.assertNull(consumer.receiveImmediate());
    session.close();
}

74. ScheduledMessageTest#testPagedMessageDeliveredMultipleConsumersCorrectly()

Project: activemq-artemis
File: ScheduledMessageTest.java
@Test
public void testPagedMessageDeliveredMultipleConsumersCorrectly() throws Exception {
    AddressSettings qs = new AddressSettings().setRedeliveryDelay(5000L);
    server.getAddressSettingsRepository().addMatch(atestq.toString(), qs);
    // then we create a client as normal
    ClientSessionFactory sessionFactory = createSessionFactory(locator);
    ClientSession session = sessionFactory.createSession(false, true, false);
    session.createQueue(atestq, atestq, null, true);
    session.createQueue(atestq, atestq2, null, true);
    ClientProducer producer = session.createProducer(atestq);
    ClientMessage message = createDurableMessage(session, "m1");
    producer.send(message);
    producer.close();
    ClientConsumer consumer = session.createConsumer(atestq);
    ClientConsumer consumer2 = session.createConsumer(atestq2);
    session.start();
    ClientMessage message3 = consumer.receive(1000);
    message3.acknowledge();
    ClientMessage message2 = consumer2.receive(1000);
    message2.acknowledge();
    Assert.assertEquals("m1", message3.getBodyBuffer().readString());
    Assert.assertEquals("m1", message2.getBodyBuffer().readString());
    long time = System.currentTimeMillis();
    // force redelivery
    consumer.close();
    consumer2.close();
    // this will make it redelivery-delay
    session.rollback();
    consumer = session.createConsumer(atestq);
    consumer2 = session.createConsumer(atestq2);
    message3 = consumer.receive(5250);
    message2 = consumer2.receive(1000);
    time += 5000;
    Assert.assertTrue(System.currentTimeMillis() >= time);
    Assert.assertEquals("m1", message3.getBodyBuffer().readString());
    Assert.assertEquals("m1", message2.getBodyBuffer().readString());
    message2.acknowledge();
    message3.acknowledge();
    // Make sure no more messages
    consumer.close();
    consumer2.close();
    consumer = session.createConsumer(atestq);
    Assert.assertNull(consumer.receiveImmediate());
    session.close();
}

75. ActiveMQRATestBase#setupDLQ()

Project: activemq-artemis
File: ActiveMQRATestBase.java
protected void setupDLQ(int maxDeliveries) {
    AddressSettings settings = new AddressSettings().setDeadLetterAddress(SimpleString.toSimpleString("jms.queue." + DLQ)).setMaxDeliveryAttempts(maxDeliveries);
    server.getAddressSettingsRepository().addMatch("#", settings);
}

76. XmlImportExportTest#testPagedLargeMessage()

Project: activemq-artemis
File: XmlImportExportTest.java
@Test
public void testPagedLargeMessage() throws Exception {
    final String MY_ADDRESS = "myAddress";
    final String MY_QUEUE = "myQueue";
    server = createServer(true);
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnNonDurableSend(// page mode and we could only guarantee that by setting it to synchronous
    true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    ClientSessionFactory factory = locator.createSessionFactory();
    ClientSession session = factory.createSession(false, true, true);
    session.createQueue(MY_ADDRESS, MY_QUEUE, true);
    ClientProducer producer = session.createProducer(MY_ADDRESS);
    ClientMessage message = session.createMessage(true);
    message.getBodyBuffer().writeBytes(new byte[1024]);
    for (int i = 0; i < 200; i++) {
        producer.send(message);
    }
    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();
    producer.send(fileMessage);
    fileMessage.deleteFile();
    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();
    checkForLongs();
    locator = createInVMNonHALocator();
    factory = locator.createSessionFactory();
    session = factory.createSession(false, true, true);
    ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
    XmlDataImporter xmlDataImporter = new XmlDataImporter();
    xmlDataImporter.process(xmlInputStream, session);
    ClientConsumer consumer = session.createConsumer(MY_QUEUE);
    session.start();
    for (int i = 0; i < 200; i++) {
        message = consumer.receive(CONSUMER_TIMEOUT);
        assertNotNull(message);
    }
    ClientMessage msg = consumer.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());
    }
    session.close();
    locator.close();
    server.stop();
}

77. XmlImportExportTest#testPaging()

Project: activemq-artemis
File: XmlImportExportTest.java
@Test
public void testPaging() throws Exception {
    final String MY_ADDRESS = "myAddress";
    final String MY_QUEUE = "myQueue";
    server = createServer(true);
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    server.start();
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(// page mode and we could only guarantee that by setting it to synchronous
    true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    factory = createSessionFactory(locator);
    ClientSession session = factory.createSession(false, true, true);
    session.createQueue(MY_ADDRESS, MY_QUEUE, true);
    ClientProducer producer = session.createProducer(MY_ADDRESS);
    ClientMessage message = session.createMessage(true);
    message.getBodyBuffer().writeBytes(new byte[1024]);
    for (int i = 0; i < 200; i++) {
        producer.send(message);
    }
    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();
    checkForLongs();
    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);
    ClientConsumer consumer = session.createConsumer(MY_QUEUE);
    session.start();
    for (int i = 0; i < 200; i++) {
        message = consumer.receive(CONSUMER_TIMEOUT);
        assertNotNull(message);
    }
}

78. XmlImportExportTest#testPagedMessageWithMissingBinding()

Project: activemq-artemis
File: XmlImportExportTest.java
@Test
public void testPagedMessageWithMissingBinding() throws Exception {
    final String MY_ADDRESS = "myAddress";
    final String MY_QUEUE = "myQueue";
    final String MY_QUEUE2 = "myQueue2";
    server = createServer(true);
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnNonDurableSend(// page mode and we could only guarantee that by setting it to synchronous
    true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    ClientSessionFactory factory = locator.createSessionFactory();
    ClientSession session = factory.createSession(false, true, true);
    session.createQueue(MY_ADDRESS, MY_QUEUE, true);
    session.createQueue(MY_ADDRESS, MY_QUEUE2, true);
    ClientProducer producer = session.createProducer(MY_ADDRESS);
    ClientMessage message = session.createMessage(true);
    message.getBodyBuffer().writeBytes(new byte[1024]);
    for (int i = 0; i < 200; i++) {
        producer.send(message);
    }
    session.deleteQueue(MY_QUEUE2);
    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();
    checkForLongs();
    locator = createInVMNonHALocator();
    factory = locator.createSessionFactory();
    session = factory.createSession(false, true, true);
    ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
    XmlDataImporter xmlDataImporter = new XmlDataImporter();
    xmlDataImporter.process(xmlInputStream, session);
    ClientConsumer consumer = session.createConsumer(MY_QUEUE);
    session.start();
    for (int i = 0; i < 200; i++) {
        message = consumer.receive(CONSUMER_TIMEOUT);
        assertNotNull(message);
    }
    session.close();
    locator.close();
    server.stop();
}

79. AddressSettingsConfigurationStorageTest#testStoreSecuritySettings()

Project: activemq-artemis
File: AddressSettingsConfigurationStorageTest.java
@Test
public void testStoreSecuritySettings() throws Exception {
    createStorage();
    AddressSettings setting = new AddressSettings();
    setting = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.BLOCK).setDeadLetterAddress(new SimpleString("some-test"));
    addAddress(journal, "a2", setting);
    journal.stop();
    createStorage();
    checkAddresses(journal);
    setting = new AddressSettings().setDeadLetterAddress(new SimpleString("new-adddress"));
    // Replacing the first setting
    addAddress(journal, "a1", setting);
    journal.stop();
    createStorage();
    checkAddresses(journal);
    journal.stop();
    journal = null;
}

80. SpawnedServerSupport#createConfig()

Project: activemq-artemis
File: SpawnedServerSupport.java
static Configuration createConfig(String folder) {
    AddressSettings settings = new AddressSettings().setMaxDeliveryAttempts(-1).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setPageSizeBytes(10 * 1024).setMaxSizeBytes(100 * 1024);
    Configuration config = new ConfigurationImpl().setSecurityEnabled(false).setJournalMinFiles(2).setJournalFileSize(100 * 1024).setJournalType(ActiveMQTestBase.getDefaultJournalType()).setJournalCompactMinFiles(0).setJournalCompactPercentage(0).setClusterPassword(ActiveMQTestBase.CLUSTER_PASSWORD).setJournalDirectory(ActiveMQTestBase.getJournalDir(folder, 0, false)).setBindingsDirectory(ActiveMQTestBase.getBindingsDir(folder, 0, false)).setPagingDirectory(ActiveMQTestBase.getPageDir(folder, 0, false)).setLargeMessagesDirectory(ActiveMQTestBase.getLargeMessagesDir(folder, 0, false)).setPersistenceEnabled(true).addAddressesSetting("#", settings).addAcceptorConfiguration(new TransportConfiguration(ActiveMQTestBase.NETTY_ACCEPTOR_FACTORY));
    return config;
}

81. PagingSendTest#testPagingDoesNotDuplicateBatchMessagesAfterPagingStarted()

Project: activemq-artemis
File: PagingSendTest.java
@Test
public void testPagingDoesNotDuplicateBatchMessagesAfterPagingStarted() throws Exception {
    int batchSize = 20;
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false);
    // Create a queue
    SimpleString queueAddr = new SimpleString("testQueue");
    session.createQueue(queueAddr, queueAddr, null, true);
    // Set up paging on the queue address
    AddressSettings addressSettings = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(16 * 1024);
    server.getAddressSettingsRepository().addMatch("#", addressSettings);
    int numberOfMessages = 0;
    // ensure the server is paging
    while (!server.getPagingManager().getPageStore(queueAddr).isPaging()) {
        sendMessageBatch(batchSize, session, queueAddr);
        numberOfMessages += batchSize;
    }
    sendMessageBatch(batchSize, session, queueAddr);
    numberOfMessages += batchSize;
    Queue queue = server.locateQueue(queueAddr);
    checkBatchMessagesAreNotPagedTwice(queue);
    for (int i = 0; i < 10; i++) {
        // execute the same count a couple times. This is to make sure the iterators have no impact regardless
        // the number of times they are called
        assertEquals(numberOfMessages, processCountThroughIterator(queue));
    }
}

82. PagingSendTest#testPagingDoesNotDuplicateBatchMessages()

Project: activemq-artemis
File: PagingSendTest.java
@Test
public void testPagingDoesNotDuplicateBatchMessages() throws Exception {
    int batchSize = 20;
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false);
    // Create a queue
    SimpleString queueAddr = new SimpleString("testQueue");
    session.createQueue(queueAddr, queueAddr, null, true);
    // Set up paging on the queue address
    AddressSettings addressSettings = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(/** This actually causes the address to start paging messages after 10 x messages with 1024 payload is sent.
          Presumably due to additional meta-data, message headers etc... **/
    16 * 1024);
    server.getAddressSettingsRepository().addMatch("#", addressSettings);
    sendMessageBatch(batchSize, session, queueAddr);
    Queue queue = server.locateQueue(queueAddr);
    // Give time Queue.deliverAsync to deliver messages
    Assert.assertTrue("Messages were not propagated to internal structures.", waitForMessages(queue, batchSize, 3000));
    checkBatchMessagesAreNotPagedTwice(queue);
    for (int i = 0; i < 10; i++) {
        // execute the same count a couple times. This is to make sure the iterators have no impact regardless
        // the number of times they are called
        assertEquals(batchSize, processCountThroughIterator(queue));
    }
}

83. PagingSendTest#newActiveMQServer()

Project: activemq-artemis
File: PagingSendTest.java
private ActiveMQServer newActiveMQServer() throws Exception {
    ActiveMQServer server = createServer(true, isNetty());
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(10 * 1024).setMaxSizeBytes(20 * 1024);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    return server;
}

84. PagingReceiveTest#newActiveMQServer()

Project: activemq-artemis
File: PagingReceiveTest.java
private ActiveMQServer newActiveMQServer() throws Exception {
    final ActiveMQServer server = createServer(true, isNetty());
    final AddressSettings settings = new AddressSettings().setMaxSizeBytes(67108864).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setMaxRedeliveryDelay(3600000).setRedeliveryMultiplier(2.0).setRedeliveryDelay(500);
    server.getAddressSettingsRepository().addMatch("#", settings);
    return server;
}

85. MultipleProducersPagingTest#setUp()

Project: activemq-artemis
File: MultipleProducersPagingTest.java
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    executor = Executors.newCachedThreadPool(ActiveMQThreadFactory.defaultThreadFactory());
    AddressSettings addressSettings = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setPageSizeBytes(50000).setMaxSizeBytes(404850);
    Configuration config = createBasicConfig().setPersistenceEnabled(false).setAddressesSettings(Collections.singletonMap("#", addressSettings)).setAcceptorConfigurations(Collections.singleton(new TransportConfiguration(NettyAcceptorFactory.class.getName()))).setConnectorConfigurations(Collections.singletonMap("netty", new TransportConfiguration(NettyConnectorFactory.class.getName())));
    final JMSConfiguration jmsConfig = new JMSConfigurationImpl();
    jmsConfig.getConnectionFactoryConfigurations().add(new ConnectionFactoryConfigurationImpl().setName("cf").setConnectorNames(Arrays.asList("netty")).setBindings("/cf"));
    jmsConfig.getQueueConfigurations().add(new JMSQueueConfigurationImpl().setName("simple").setSelector("").setDurable(false).setBindings("/queue/simple"));
    jmsServer = new EmbeddedJMS();
    jmsServer.setConfiguration(config);
    jmsServer.setJmsConfiguration(jmsConfig);
    jmsServer.start();
    cf = (ConnectionFactory) jmsServer.lookup("/cf");
    queue = (Queue) jmsServer.lookup("/queue/simple");
    barrierLatch = new CyclicBarrier(PRODUCERS + 1);
    runnersLatch = new CountDownLatch(PRODUCERS + 1);
    msgReceived = new AtomicLong(0);
    msgSent = new AtomicLong(0);
}

86. QueueControlTest#testSendMessageToDeadLetterAddress()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testSendMessageToDeadLetterAddress() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString deadLetterAddress = RandomUtil.randomSimpleString();
    SimpleString deadLetterQueue = RandomUtil.randomSimpleString();
    session.createQueue(address, queue, null, false);
    session.createQueue(deadLetterAddress, deadLetterQueue, null, false);
    ClientProducer producer = session.createProducer(address);
    // send 2 messages on queue
    producer.send(session.createMessage(false));
    producer.send(session.createMessage(false));
    QueueControl queueControl = createManagementControl(address, queue);
    QueueControl deadLetterQueueControl = createManagementControl(deadLetterAddress, deadLetterQueue);
    Assert.assertEquals(2, getMessageCount(queueControl));
    // the message IDs are set on the server
    Map<String, Object>[] messages = queueControl.listMessages(null);
    Assert.assertEquals(2, messages.length);
    long messageID = (Long) messages[0].get("messageID");
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(deadLetterAddress);
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    Assert.assertEquals(0, getMessageCount(deadLetterQueueControl));
    boolean movedToDeadLetterAddress = queueControl.sendMessageToDeadLetterAddress(messageID);
    Assert.assertTrue(movedToDeadLetterAddress);
    Assert.assertEquals(1, getMessageCount(queueControl));
    Assert.assertEquals(1, getMessageCount(deadLetterQueueControl));
    // check there is a single message to consume from queue
    consumeMessages(1, session, queue);
    // check there is a single message to consume from deadletter queue
    consumeMessages(1, session, deadLetterQueue);
    session.deleteQueue(queue);
    session.deleteQueue(deadLetterQueue);
}

87. QueueControlTest#testExpireMessage()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testExpireMessage() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString expiryAddress = RandomUtil.randomSimpleString();
    SimpleString expiryQueue = RandomUtil.randomSimpleString();
    session.createQueue(address, queue, null, false);
    session.createQueue(expiryAddress, expiryQueue, null, false);
    ClientProducer producer = session.createProducer(address);
    // send on queue
    producer.send(session.createMessage(false));
    QueueControl queueControl = createManagementControl(address, queue);
    QueueControl expiryQueueControl = createManagementControl(expiryAddress, expiryQueue);
    Assert.assertEquals(1, getMessageCount(queueControl));
    Assert.assertEquals(0, getMessageCount(expiryQueueControl));
    // the message IDs are set on the server
    Map<String, Object>[] messages = queueControl.listMessages(null);
    Assert.assertEquals(1, messages.length);
    long messageID = (Long) messages[0].get("messageID");
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(expiryAddress);
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    boolean expired = queueControl.expireMessage(messageID);
    Assert.assertTrue(expired);
    Assert.assertEquals(0, getMessageCount(queueControl));
    Assert.assertEquals(1, getMessageCount(expiryQueueControl));
    consumeMessages(0, session, queue);
    consumeMessages(1, session, expiryQueue);
    session.deleteQueue(queue);
    session.deleteQueue(expiryQueue);
    session.close();
}

88. QueueControlTest#testRetryMultipleMessages()

Project: activemq-artemis
File: QueueControlTest.java
/**
    * Test retry multiple messages from  DLQ to original queue.
    */
@Test
public void testRetryMultipleMessages() throws Exception {
    final SimpleString dla = new SimpleString("DLA");
    final SimpleString qName = new SimpleString("q1");
    final SimpleString adName = new SimpleString("ad1");
    final SimpleString dlq = new SimpleString("DLQ1");
    final String sampleText = "Put me on DLQ";
    final int numMessagesToTest = 10;
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1).setDeadLetterAddress(dla);
    server.getAddressSettingsRepository().addMatch(adName.toString(), addressSettings);
    session.createQueue(dla, dlq, null, false);
    session.createQueue(adName, qName, null, false);
    // Send message to queue.
    ClientProducer producer = session.createProducer(adName);
    for (int i = 0; i < numMessagesToTest; i++) {
        producer.send(createTextMessage(session, sampleText));
    }
    session.start();
    // Read and rollback all messages to DLQ
    ClientConsumer clientConsumer = session.createConsumer(qName);
    for (int i = 0; i < numMessagesToTest; i++) {
        ClientMessage clientMessage = clientConsumer.receive(500);
        clientMessage.acknowledge();
        Assert.assertNotNull(clientMessage);
        Assert.assertEquals(clientMessage.getBodyBuffer().readString(), sampleText);
        session.rollback();
    }
    Assert.assertNull(clientConsumer.receiveImmediate());
    QueueControl dlqQueueControl = createManagementControl(dla, dlq);
    Assert.assertEquals(numMessagesToTest, getMessageCount(dlqQueueControl));
    // Retry all messages - i.e. they should go from DLQ to original Queue.
    Assert.assertEquals(numMessagesToTest, dlqQueueControl.retryMessages());
    // Assert DLQ is empty...
    Assert.assertEquals(0, getMessageCount(dlqQueueControl));
    // .. and that the messages is now on the original queue once more.
    for (int i = 0; i < numMessagesToTest; i++) {
        ClientMessage clientMessage = clientConsumer.receive(500);
        clientMessage.acknowledge();
        Assert.assertNotNull(clientMessage);
        Assert.assertEquals(clientMessage.getBodyBuffer().readString(), sampleText);
    }
    clientConsumer.close();
}

89. QueueControlTest#testRetryMessage()

Project: activemq-artemis
File: QueueControlTest.java
/**
    * Test retry - get a message from DLQ and put on original queue.
    */
@Test
public void testRetryMessage() throws Exception {
    final SimpleString dla = new SimpleString("DLA");
    final SimpleString qName = new SimpleString("q1");
    final SimpleString adName = new SimpleString("ad1");
    final SimpleString dlq = new SimpleString("DLQ1");
    final String sampleText = "Put me on DLQ";
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1).setDeadLetterAddress(dla);
    server.getAddressSettingsRepository().addMatch(adName.toString(), addressSettings);
    session.createQueue(dla, dlq, null, false);
    session.createQueue(adName, qName, null, false);
    // Send message to queue.
    ClientProducer producer = session.createProducer(adName);
    producer.send(createTextMessage(session, sampleText));
    session.start();
    ClientConsumer clientConsumer = session.createConsumer(qName);
    ClientMessage clientMessage = clientConsumer.receive(500);
    clientMessage.acknowledge();
    Assert.assertNotNull(clientMessage);
    Assert.assertEquals(clientMessage.getBodyBuffer().readString(), sampleText);
    // force a rollback to DLQ
    session.rollback();
    clientMessage = clientConsumer.receiveImmediate();
    Assert.assertNull(clientMessage);
    QueueControl queueControl = createManagementControl(dla, dlq);
    Assert.assertEquals(1, getMessageCount(queueControl));
    final long messageID = getFirstMessageId(queueControl);
    // Retry the message - i.e. it should go from DLQ to original Queue.
    Assert.assertTrue(queueControl.retryMessage(messageID));
    // Assert DLQ is empty...
    Assert.assertEquals(0, getMessageCount(queueControl));
    // .. and that the message is now on the original queue once more.
    clientMessage = clientConsumer.receive(500);
    clientMessage.acknowledge();
    Assert.assertNotNull(clientMessage);
    Assert.assertEquals(sampleText, clientMessage.getBodyBuffer().readString());
    clientConsumer.close();
}

90. AddressControlTest#testGetNumberOfPages()

Project: activemq-artemis
File: AddressControlTest.java
@Test
public void testGetNumberOfPages() throws Exception {
    session.close();
    server.stop();
    server.getConfiguration().setPersistenceEnabled(true);
    SimpleString address = RandomUtil.randomSimpleString();
    AddressSettings addressSettings = new AddressSettings().setPageSizeBytes(1024).setMaxSizeBytes(10 * 1024);
    final int NUMBER_MESSAGES_BEFORE_PAGING = 7;
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    server.start();
    ServerLocator locator2 = createInVMNonHALocator();
    addServerLocator(locator2);
    ClientSessionFactory sf2 = createSessionFactory(locator2);
    session = sf2.createSession(false, true, false);
    session.start();
    session.createQueue(address, address, true);
    QueueImpl serverQueue = (QueueImpl) server.locateQueue(address);
    ClientProducer producer = session.createProducer(address);
    for (int i = 0; i < NUMBER_MESSAGES_BEFORE_PAGING; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.getBodyBuffer().writeBytes(new byte[896]);
        producer.send(msg);
    }
    session.commit();
    AddressControl addressControl = createManagementControl(address);
    Assert.assertEquals(0, addressControl.getNumberOfPages());
    ClientMessage msg = session.createMessage(true);
    msg.getBodyBuffer().writeBytes(new byte[896]);
    producer.send(msg);
    session.commit();
    Assert.assertEquals(1, addressControl.getNumberOfPages());
    msg = session.createMessage(true);
    msg.getBodyBuffer().writeBytes(new byte[896]);
    producer.send(msg);
    session.commit();
    Assert.assertEquals(1, addressControl.getNumberOfPages());
    msg = session.createMessage(true);
    msg.getBodyBuffer().writeBytes(new byte[896]);
    producer.send(msg);
    session.commit();
    Assert.assertEquals("# of pages is 2", 2, addressControl.getNumberOfPages());
    System.out.println("Address size=" + addressControl.getAddressSize());
    Assert.assertEquals(serverQueue.getPageSubscription().getPagingStore().getAddressSize(), addressControl.getAddressSize());
}

91. JMSQueueControlTest#testDeleteWithPagingAndFilter()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testDeleteWithPagingAndFilter() throws Exception {
    AddressSettings pagedSetting = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setPageSizeBytes(10 * 1024).setMaxSizeBytes(100 * 1024);
    server.getAddressSettingsRepository().addMatch("#", pagedSetting);
    serverManager.createQueue(true, "pagedTest", null, true, "/queue/pagedTest");
    ActiveMQQueue pagedQueue = (ActiveMQQueue) context.lookup("/queue/pagedTest");
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true);
    ClientProducer prod = session.createProducer(pagedQueue.getAddress());
    for (int i = 0; i < 200; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.getBodyBuffer().writeBytes(new byte[90 * 1024]);
        msg.putBooleanProperty("even", i % 2 == 0);
        prod.send(msg);
    }
    JMSQueueControl control = createManagementControl(pagedQueue);
    assertEquals(100, control.removeMessages("even=true"));
    session.start();
    ClientConsumer consumer = session.createConsumer(pagedQueue.getAddress());
    for (int i = 0; i < 100; i++) {
        ClientMessage msg = consumer.receive(1000);
        assertNotNull(msg);
        msg.acknowledge();
        assertFalse(msg.getBooleanProperty("even").booleanValue());
    }
    assertNull(consumer.receive(300));
    session.close();
    sf.close();
    locator.close();
}

92. JMSQueueControlTest#testDeleteWithPaging()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testDeleteWithPaging() throws Exception {
    AddressSettings pagedSetting = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setPageSizeBytes(10 * 1024).setMaxSizeBytes(100 * 1024);
    server.getAddressSettingsRepository().addMatch("#", pagedSetting);
    serverManager.createQueue(true, "pagedTest", null, true, "/queue/pagedTest");
    ActiveMQQueue pagedQueue = (ActiveMQQueue) context.lookup("/queue/pagedTest");
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true);
    ClientProducer prod = session.createProducer(pagedQueue.getAddress());
    ClientMessage msg = session.createMessage(true);
    msg.getBodyBuffer().writeBytes(new byte[90 * 1024]);
    for (int i = 0; i < 100; i++) {
        prod.send(msg);
    }
    JMSQueueControl control = createManagementControl(pagedQueue);
    assertEquals(100, control.removeMessages("     "));
    session.start();
    ClientConsumer consumer = session.createConsumer(pagedQueue.getAddress());
    assertNull(consumer.receive(300));
    session.close();
    sf.close();
    locator.close();
}

93. JMSQueueControlTest#testSendMessagesToDeadLetterAddress()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testSendMessagesToDeadLetterAddress() throws Exception {
    String key = "key";
    long matchingValue = RandomUtil.randomLong();
    long unmatchingValue = matchingValue + 1;
    String filter = "key = " + matchingValue;
    String deadLetterQueue = RandomUtil.randomString();
    serverManager.createQueue(false, deadLetterQueue, null, true, deadLetterQueue);
    ActiveMQQueue dlq = (ActiveMQQueue) ActiveMQJMSClient.createQueue(deadLetterQueue);
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(new SimpleString(dlq.getAddress()));
    server.getAddressSettingsRepository().addMatch(queue.getAddress(), addressSettings);
    Connection conn = createConnection();
    Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    // send 2 messages on queue
    JMSUtil.sendMessageWithProperty(sess, queue, key, matchingValue);
    JMSUtil.sendMessageWithProperty(sess, queue, key, unmatchingValue);
    JMSQueueControl queueControl = createManagementControl();
    JMSQueueControl dlqControl = ManagementControlHelper.createJMSQueueControl(dlq, mbeanServer);
    Assert.assertEquals(2, getMessageCount(queueControl));
    Assert.assertEquals(0, getMessageCount(dlqControl));
    //      queueControl.setDeadLetterAddress(dlq.getAddress());
    int deadMessageCount = queueControl.sendMessagesToDeadLetterAddress(filter);
    Assert.assertEquals(1, deadMessageCount);
    Assert.assertEquals(1, getMessageCount(queueControl));
    Assert.assertEquals(1, getMessageCount(dlqControl));
    conn.start();
    MessageConsumer consumer = sess.createConsumer(queue);
    Message message = consumer.receive(500);
    Assert.assertNotNull(message);
    Assert.assertEquals(unmatchingValue, message.getLongProperty(key));
    // check there is a single message to consume from deadletter queue
    JMSUtil.consumeMessages(1, dlq);
    conn.close();
    serverManager.destroyQueue(deadLetterQueue);
}

94. JMSQueueControlTest#testSendMessageToDeadLetterAddress()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testSendMessageToDeadLetterAddress() throws Exception {
    String deadLetterQueue = RandomUtil.randomString();
    serverManager.createQueue(false, deadLetterQueue, null, true, deadLetterQueue);
    ActiveMQQueue dlq = (ActiveMQQueue) ActiveMQJMSClient.createQueue(deadLetterQueue);
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(new SimpleString(dlq.getAddress()));
    server.getAddressSettingsRepository().addMatch(queue.getAddress(), addressSettings);
    Connection conn = createConnection();
    Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageProducer producer = sess.createProducer(queue);
    // send 2 messages on queue
    Message message = sess.createMessage();
    producer.send(message);
    producer.send(sess.createMessage());
    conn.close();
    JMSQueueControl queueControl = createManagementControl();
    JMSQueueControl dlqControl = ManagementControlHelper.createJMSQueueControl(dlq, mbeanServer);
    Assert.assertEquals(2, getMessageCount(queueControl));
    Assert.assertEquals(0, getMessageCount(dlqControl));
    //      queueControl.setDeadLetterAddress(dlq.getAddress());
    boolean movedToDeadLetterAddress = queueControl.sendMessageToDeadLetterAddress(message.getJMSMessageID());
    Assert.assertTrue(movedToDeadLetterAddress);
    Assert.assertEquals(1, getMessageCount(queueControl));
    Assert.assertEquals(1, getMessageCount(dlqControl));
    // check there is a single message to consume from queue
    JMSUtil.consumeMessages(1, queue);
    // check there is a single message to consume from deadletter queue
    JMSUtil.consumeMessages(1, dlq);
    serverManager.destroyQueue(deadLetterQueue);
}

95. JMSQueueControlTest#testExpireMessage()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testExpireMessage() throws Exception {
    JMSQueueControl queueControl = createManagementControl();
    String expiryQueueName = RandomUtil.randomString();
    ActiveMQQueue expiryQueue = (ActiveMQQueue) ActiveMQJMSClient.createQueue(expiryQueueName);
    serverManager.createQueue(false, expiryQueueName, null, true, expiryQueueName);
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(new SimpleString(expiryQueue.getAddress()));
    server.getAddressSettingsRepository().addMatch(queue.getAddress(), addressSettings);
    //      queueControl.setExpiryAddress(expiryQueue.getAddress());
    JMSQueueControl expiryQueueControl = ManagementControlHelper.createJMSQueueControl(expiryQueue, mbeanServer);
    String[] messageIDs = JMSUtil.sendMessages(queue, 1);
    Assert.assertEquals(1, getMessageCount(queueControl));
    Assert.assertEquals(0, getMessageCount(expiryQueueControl));
    Assert.assertTrue(queueControl.expireMessage(messageIDs[0]));
    Assert.assertEquals(0, getMessageCount(queueControl));
    Assert.assertEquals(1, getMessageCount(expiryQueueControl));
    Connection connection = JMSUtil.createConnection(InVMConnectorFactory.class.getName());
    connection.start();
    MessageConsumer consumer = JMSUtil.createConsumer(connection, expiryQueue);
    Message message = consumer.receive(500);
    Assert.assertNotNull(message);
    Assert.assertEquals(messageIDs[0], message.getJMSMessageID());
    connection.close();
}

96. DivertTest#testSingleDivertWithExpiry()

Project: activemq-artemis
File: DivertTest.java
@Test
public void testSingleDivertWithExpiry() throws Exception {
    final String testAddress = "testAddress";
    final String forwardAddress = "forwardAddress";
    final String expiryAddress = "expiryAddress";
    AddressSettings expirySettings = new AddressSettings().setExpiryAddress(new SimpleString(expiryAddress));
    DivertConfiguration divertConf = new DivertConfiguration().setName("divert1").setRoutingName("divert1").setAddress(testAddress).setForwardingAddress(forwardAddress);
    Configuration config = createDefaultInVMConfig().addDivertConfiguration(divertConf).clearAddressesSettings().addAddressesSetting("#", expirySettings);
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config, true));
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    final SimpleString queueName1 = new SimpleString("queue1");
    final SimpleString queueName2 = new SimpleString("queue2");
    session.createQueue(new SimpleString(forwardAddress), queueName1, null, true);
    session.createQueue(new SimpleString(testAddress), queueName2, null, true);
    session.createQueue(new SimpleString(expiryAddress), new SimpleString(expiryAddress), null, true);
    session.start();
    ClientProducer producer = session.createProducer(new SimpleString(testAddress));
    ClientConsumer consumer1 = session.createConsumer(queueName1);
    ClientConsumer consumer2 = session.createConsumer(queueName2);
    final int numMessages = 1;
    final SimpleString propKey = new SimpleString("testkey");
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(true);
        message.putIntProperty(propKey, i);
        message.setExpiration(System.currentTimeMillis() + 1000);
        producer.send(message);
    }
    session.commit();
    // this context is validating if these messages are routed correctly
    {
        int count1 = 0;
        ClientMessage message = null;
        while ((message = consumer1.receiveImmediate()) != null) {
            message.acknowledge();
            count1++;
        }
        int count2 = 0;
        while ((message = consumer2.receiveImmediate()) != null) {
            message.acknowledge();
            count2++;
        }
        assertEquals(1, count1);
        assertEquals(1, count2);
        session.rollback();
    }
    Thread.sleep(2000);
    // it must been expired by now
    assertNull(consumer1.receiveImmediate());
    // it must been expired by now
    assertNull(consumer2.receiveImmediate());
    int countOriginal1 = 0;
    int countOriginal2 = 0;
    ClientConsumer consumerExpiry = session.createConsumer(expiryAddress);
    for (int i = 0; i < numMessages * 2; i++) {
        ClientMessage message = consumerExpiry.receive(5000);
        System.out.println("Received message " + message);
        assertNotNull(message);
        if (message.getStringProperty(Message.HDR_ORIGINAL_QUEUE).equals("queue1")) {
            countOriginal1++;
        } else if (message.getStringProperty(Message.HDR_ORIGINAL_QUEUE).equals("queue2")) {
            countOriginal2++;
        } else {
            System.out.println("message not part of any expired queue" + message);
        }
    }
    assertEquals(numMessages, countOriginal1);
    assertEquals(numMessages, countOriginal2);
}

97. ReplicatedDistributionTest#setUp()

Project: activemq-artemis
File: ReplicatedDistributionTest.java
@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    setupLiveServer(1, true, isSharedStore(), true, false);
    setupLiveServer(3, true, isSharedStore(), true, false);
    setupBackupServer(2, 3, true, isSharedStore(), true);
    final String address = ReplicatedDistributionTest.ADDRESS.toString();
    // notice the abuse of the method call, '3' is not a backup for '1'
    setupClusterConnectionWithBackups("test", address, MessageLoadBalancingType.ON_DEMAND, 1, true, 1, new int[] { 3 });
    setupClusterConnectionWithBackups("test", address, MessageLoadBalancingType.ON_DEMAND, 1, true, 3, new int[] { 2, 1 });
    setupClusterConnectionWithBackups("test", address, MessageLoadBalancingType.ON_DEMAND, 1, true, 2, new int[] { 3 });
    AddressSettings as = new AddressSettings().setRedistributionDelay(0);
    for (int i : new int[] { 1, 2, 3 }) {
        getServer(i).getAddressSettingsRepository().addMatch("test.*", as);
        getServer(i).start();
    }
    setupSessionFactory(1, -1, true, true);
    setupSessionFactory(3, 2, true, true);
    sessionOne = sfs[1].createSession(true, true);
    sessionThree = sfs[3].createSession(false, false);
    sessionOne.createQueue(ReplicatedDistributionTest.ADDRESS, ReplicatedDistributionTest.ADDRESS, true);
    sessionThree.createQueue(ReplicatedDistributionTest.ADDRESS, ReplicatedDistributionTest.ADDRESS, true);
    consThree = sessionThree.createConsumer(ReplicatedDistributionTest.ADDRESS);
    sessionThree.start();
}

98. BackupSyncPagingTest#createInVMFailoverServer()

Project: activemq-artemis
File: BackupSyncPagingTest.java
@Override
protected ActiveMQServer createInVMFailoverServer(final boolean realFiles, final Configuration configuration, final NodeManager nodeManager, int id) {
    Map<String, AddressSettings> conf = new HashMap<>();
    AddressSettings as = new AddressSettings().setMaxSizeBytes(PAGE_MAX).setPageSizeBytes(PAGE_SIZE).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    conf.put(ADDRESS.toString(), as);
    return createInVMFailoverServer(realFiles, configuration, PAGE_SIZE, PAGE_MAX, conf, nodeManager, id);
}

99. MessageRedistributionWithDiscoveryTest#setServer()

Project: activemq-artemis
File: MessageRedistributionWithDiscoveryTest.java
/**
    * @param messageLoadBalancingType
    * @throws Exception
    */
protected void setServer(final MessageLoadBalancingType messageLoadBalancingType, int server) throws Exception {
    setupLiveServerWithDiscovery(server, groupAddress, groupPort, isFileStorage(), isNetty(), false);
    AddressSettings setting = new AddressSettings().setRedeliveryDelay(0).setRedistributionDelay(0);
    servers[server].getAddressSettingsRepository().addMatch("#", setting);
    setupDiscoveryClusterConnection("cluster" + server, server, "dg1", "queues", messageLoadBalancingType, 1, isNetty());
}

100. MessageRedistributionTest#setRedistributionDelay()

Project: activemq-artemis
File: MessageRedistributionTest.java
protected void setRedistributionDelay(final long delay) {
    AddressSettings as = new AddressSettings().setRedistributionDelay(delay);
    getServer(0).getAddressSettingsRepository().addMatch("queues.*", as);
    getServer(1).getAddressSettingsRepository().addMatch("queues.*", as);
    getServer(2).getAddressSettingsRepository().addMatch("queues.*", as);
}