org.apache.activemq.artemis.core.server.Queue

Here are the examples of the java api class org.apache.activemq.artemis.core.server.Queue taken from open source projects.

1. LVQTest#testRemoveMessageThroughManagement()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testRemoveMessageThroughManagement() throws Exception {
    Queue queue = server.locateQueue(qName1);
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    SimpleString rh = new SimpleString("SMID1");
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m1.setDurable(true);
    producer.send(m1);
    queue.deleteAllReferences();
    producer.send(m1);
    clientSession.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
    assertEquals(0, queue.getDeliveringCount());
}

2. SecurityTest#testNonBlockSendManagementWithoutRole()

Project: activemq-artemis
File: SecurityTest.java
@Test
public void testNonBlockSendManagementWithoutRole() throws Exception {
    ActiveMQServer server = createServer();
    server.start();
    HierarchicalRepository<Set<Role>> securityRepository = server.getSecurityRepository();
    ActiveMQJAASSecurityManager securityManager = (ActiveMQJAASSecurityManager) server.getSecurityManager();
    securityManager.getConfiguration().addUser("auser", "pass");
    Role role = new Role("arole", false, false, true, false, false, false, false);
    Set<Role> roles = new HashSet<>();
    roles.add(role);
    securityRepository.addMatch(configuration.getManagementAddress().toString(), roles);
    securityManager.getConfiguration().addRole("auser", "arole");
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession session = cf.createSession("auser", "pass", false, true, true, false, -1);
    session.createQueue(configuration.getManagementAddress().toString(), SecurityTest.queueA, true);
    ClientProducer cp = session.createProducer(configuration.getManagementAddress());
    cp.send(session.createMessage(false));
    session.close();
    Queue binding = (Queue) server.getPostOffice().getBinding(new SimpleString(SecurityTest.queueA)).getBindable();
    Assert.assertEquals(0, getMessageCount(binding));
}

3. SecurityTest#testNonBlockSendWithoutRole()

Project: activemq-artemis
File: SecurityTest.java
@Test
public void testNonBlockSendWithoutRole() throws Exception {
    ActiveMQServer server = createServer();
    server.start();
    HierarchicalRepository<Set<Role>> securityRepository = server.getSecurityRepository();
    ActiveMQJAASSecurityManager securityManager = (ActiveMQJAASSecurityManager) server.getSecurityManager();
    securityManager.getConfiguration().addUser("auser", "pass");
    Role role = new Role("arole", false, false, true, false, false, false, false);
    Set<Role> roles = new HashSet<>();
    roles.add(role);
    securityRepository.addMatch(SecurityTest.addressA, roles);
    securityManager.getConfiguration().addRole("auser", "arole");
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession session = cf.createSession("auser", "pass", false, true, true, false, -1);
    session.createQueue(SecurityTest.addressA, SecurityTest.queueA, true);
    ClientProducer cp = session.createProducer(SecurityTest.addressA);
    cp.send(session.createMessage(false));
    session.close();
    Queue binding = (Queue) server.getPostOffice().getBinding(new SimpleString(SecurityTest.queueA)).getBindable();
    Assert.assertEquals(0, getMessageCount(binding));
}

4. ProtonTest#testMessagesSentTransactionalRolledBack()

Project: activemq-artemis
File: ProtonTest.java
@Test
public void testMessagesSentTransactionalRolledBack() throws Exception {
    int numMessages = 1;
    javax.jms.Queue queue = createQueue(address);
    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    MessageProducer p = session.createProducer(queue);
    byte[] bytes = new byte[2048];
    new Random().nextBytes(bytes);
    for (int i = 0; i < numMessages; i++) {
        TextMessage message = session.createTextMessage();
        message.setText("msg:" + i);
        p.send(message);
    }
    session.close();
    connection.close();
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(coreAddress)).getBindable();
    Assert.assertEquals(getMessageCount(q), 0);
}

5. ProtonTest#testMessagesSentTransactional()

Project: activemq-artemis
File: ProtonTest.java
@Test
public void testMessagesSentTransactional() throws Exception {
    int numMessages = 1000;
    javax.jms.Queue queue = createQueue(address);
    Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
    MessageProducer p = session.createProducer(queue);
    byte[] bytes = new byte[2048];
    new Random().nextBytes(bytes);
    for (int i = 0; i < numMessages; i++) {
        TextMessage message = session.createTextMessage();
        message.setText("msg:" + i);
        p.send(message);
    }
    session.commit();
    connection.close();
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(coreAddress)).getBindable();
    for (long timeout = System.currentTimeMillis() + 5000; timeout > System.currentTimeMillis() && getMessageCount(q) != numMessages; ) {
        Thread.sleep(1);
    }
    Assert.assertEquals(numMessages, getMessageCount(q));
}

6. ProtonTest#testConnection()

Project: activemq-artemis
File: ProtonTest.java
@Test
public void testConnection() throws Exception {
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageConsumer cons = session.createConsumer(createQueue(address));
    org.apache.activemq.artemis.core.server.Queue serverQueue = server.locateQueue(SimpleString.toSimpleString(coreAddress));
    assertEquals(1, serverQueue.getConsumerCount());
    cons.close();
    for (int i = 0; i < 100 && serverQueue.getConsumerCount() != 0; i++) {
        Thread.sleep(500);
    }
    assertEquals(0, serverQueue.getConsumerCount());
    session.close();
}

7. 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);
}

8. ManagementServiceImplTest#testGetResources()

Project: activemq-artemis
File: ManagementServiceImplTest.java
@Test
public void testGetResources() throws Exception {
    Configuration config = createBasicConfig().setJMXManagementEnabled(false);
    ManagementServiceImpl managementService = new ManagementServiceImpl(null, config);
    managementService.setStorageManager(new NullStorageManager());
    SimpleString address = RandomUtil.randomSimpleString();
    managementService.registerAddress(address);
    Queue queue = new FakeQueue(RandomUtil.randomSimpleString());
    managementService.registerQueue(queue, RandomUtil.randomSimpleString(), new FakeStorageManager());
    Object[] addresses = managementService.getResources(AddressControl.class);
    Assert.assertEquals(1, addresses.length);
    Assert.assertTrue(addresses[0] instanceof AddressControl);
    AddressControl addressControl = (AddressControl) addresses[0];
    Assert.assertEquals(address.toString(), addressControl.getAddress());
    Object[] queues = managementService.getResources(QueueControl.class);
    Assert.assertEquals(1, queues.length);
    Assert.assertTrue(queues[0] instanceof QueueControl);
    QueueControl queueControl = (QueueControl) queues[0];
    Assert.assertEquals(queue.getName().toString(), queueControl.getName());
}

9. MultipleServerFailoverTestBase#waitForDistribution()

Project: activemq-artemis
File: MultipleServerFailoverTestBase.java
protected void waitForDistribution(SimpleString address, ActiveMQServer server, int messageCount) throws Exception {
    ActiveMQServerLogger.LOGGER.debug("waiting for distribution of messages on server " + server);
    long start = System.currentTimeMillis();
    long timeout = 5000;
    Queue q = (Queue) server.getPostOffice().getBinding(address).getBindable();
    do {
        if (getMessageCount(q) >= messageCount) {
            return;
        }
        Thread.sleep(10);
    } while (System.currentTimeMillis() - start < timeout);
    throw new Exception();
}

10. TransactionalSendTest#testSendWithRollback()

Project: activemq-artemis
File: TransactionalSendTest.java
@Test
public void testSendWithRollback() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession session = cf.createSession(false, false, false);
    session.createQueue(addressA, queueA, false);
    ClientProducer cp = session.createProducer(addressA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(session.createMessage(false));
    }
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(getMessageCount(q), 0);
    session.rollback();
    Assert.assertEquals(getMessageCount(q), 0);
    // now send some more
    for (int i = 0; i < numMessages; i++) {
        cp.send(session.createMessage(false));
    }
    Assert.assertEquals(0, getMessageCount(q));
    session.commit();
    Assert.assertEquals(numMessages, getMessageCount(q));
    session.close();
}

11. TransactionalSendTest#testSendWithCommit()

Project: activemq-artemis
File: TransactionalSendTest.java
@Test
public void testSendWithCommit() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession session = cf.createSession(false, false, false);
    session.createQueue(addressA, queueA, false);
    ClientProducer cp = session.createProducer(addressA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(session.createMessage(false));
    }
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(0, getMessageCount(q));
    session.commit();
    Assert.assertEquals(getMessageCount(q), numMessages);
    // now send some more
    for (int i = 0; i < numMessages; i++) {
        cp.send(session.createMessage(false));
    }
    Assert.assertEquals(numMessages, getMessageCount(q));
    session.commit();
    Assert.assertEquals(numMessages * 2, getMessageCount(q));
    session.close();
}

12. SessionTest#testRollbackWithSend()

Project: activemq-artemis
File: SessionTest.java
@Test
public void testRollbackWithSend() throws Exception {
    cf = createSessionFactory(locator);
    ClientSession clientSession = cf.createSession(false, false, true);
    clientSession.createQueue(queueName, queueName, false);
    ClientProducer cp = clientSession.createProducer(queueName);
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(queueName)).getBindable();
    Assert.assertEquals(0, getMessageCount(q));
    clientSession.rollback();
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    clientSession.commit();
    Assert.assertEquals(2, getMessageCount(q));
    clientSession.close();
}

13. SessionTest#testCommitWithSend()

Project: activemq-artemis
File: SessionTest.java
@Test
public void testCommitWithSend() throws Exception {
    cf = createSessionFactory(locator);
    ClientSession clientSession = cf.createSession(false, false, true);
    clientSession.createQueue(queueName, queueName, false);
    ClientProducer cp = clientSession.createProducer(queueName);
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(queueName)).getBindable();
    Assert.assertEquals(0, getMessageCount(q));
    clientSession.commit();
    Assert.assertEquals(10, getMessageCount(q));
    clientSession.close();
}

14. 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());
}

15. AutoCreateJmsDestinationTest#testAutoCreateOnConsumeFromQueue()

Project: activemq-artemis
File: AutoCreateJmsDestinationTest.java
@Test
public void testAutoCreateOnConsumeFromQueue() throws Exception {
    Connection connection = null;
    connection = cf.createConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    javax.jms.Queue queue = ActiveMQJMSClient.createQueue("test");
    MessageConsumer messageConsumer = session.createConsumer(queue);
    connection.start();
    Message m = messageConsumer.receive(500);
    Assert.assertNull(m);
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString("jms.queue.test")).getBindable();
    Assert.assertEquals(0, q.getMessageCount());
    Assert.assertEquals(0, q.getMessagesAdded());
    connection.close();
}

16. 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;
}

17. PostOfficeJournalLoader#handlePreparedAcknowledge()

Project: activemq-artemis
File: PostOfficeJournalLoader.java
@Override
public void handlePreparedAcknowledge(long messageID, List<MessageReference> referencesToAck, long queueID) throws Exception {
    Queue queue = queues.get(queueID);
    if (queue == null) {
        throw new IllegalStateException("Cannot find queue with id " + queueID);
    }
    MessageReference removed = queue.removeReferenceWithID(messageID);
    if (removed == null) {
        ActiveMQServerLogger.LOGGER.journalErrorRemovingRef(messageID);
    } else {
        referencesToAck.add(removed);
    }
}

18. PostOfficeJournalLoader#postLoad()

Project: activemq-artemis
File: PostOfficeJournalLoader.java
@Override
public void postLoad(Journal messageJournal, ResourceManager resourceManager, Map<SimpleString, List<Pair<byte[], Long>>> duplicateIDMap) throws Exception {
    for (Queue queue : queues.values()) {
        queue.resume();
    }
    if (System.getProperty("org.apache.activemq.opt.directblast") != null) {
        messageJournal.runDirectJournalBlast();
    }
}

19. ActiveMQServerImpl#createSharedQueue()

Project: activemq-artemis
File: ActiveMQServerImpl.java
/**
    * Creates a transient queue. A queue that will exist as long as there are consumers.
    * The queue will be deleted as soon as all the consumers are removed.
    * <p>
    * Notice: the queue won't be deleted until the first consumer arrives.
    *
    * @param address
    * @param name
    * @param filterString
    * @param durable
    * @throws Exception
    */
@Override
public void createSharedQueue(final SimpleString address, final SimpleString name, final SimpleString filterString, final SimpleString user, boolean durable) throws Exception {
    Queue queue = createQueue(address, name, filterString, user, durable, !durable, true, !durable, false);
    if (!queue.getAddress().equals(address)) {
        throw ActiveMQMessageBundle.BUNDLE.queueSubscriptionBelongsToDifferentAddress(name);
    }
    if (filterString != null && (queue.getFilter() == null || !queue.getFilter().getFilterString().equals(filterString)) || filterString == null && queue.getFilter() != null) {
        throw ActiveMQMessageBundle.BUNDLE.queueSubscriptionBelongsToDifferentFilter(name);
    }
    if (logger.isDebugEnabled()) {
        logger.debug("Transient Queue " + name + " created on address " + name + " with filter=" + filterString);
    }
}

20. AbstractJournalStorageManager#addQueueBinding()

Project: activemq-artemis
File: AbstractJournalStorageManager.java
// BindingsImpl operations
@Override
public void addQueueBinding(final long tx, final Binding binding) throws Exception {
    Queue queue = (Queue) binding.getBindable();
    Filter filter = queue.getFilter();
    SimpleString filterString = filter == null ? null : filter.getFilterString();
    PersistentQueueBindingEncoding bindingEncoding = new PersistentQueueBindingEncoding(queue.getName(), binding.getAddress(), filterString, queue.getUser(), queue.isAutoCreated());
    readLock();
    try {
        bindingsJournal.appendAddRecordTransactional(tx, binding.getID(), JournalRecordIds.QUEUE_BINDING_RECORD, bindingEncoding);
    } finally {
        readUnLock();
    }
}

21. MQTTRetainMessageManager#addRetainedMessagesToQueue()

Project: activemq-artemis
File: MQTTRetainMessageManager.java
void addRetainedMessagesToQueue(SimpleString queueName, String address) throws Exception {
    // Queue to add the retained messages to
    Queue queue = session.getServer().locateQueue(queueName);
    // The address filter that matches all retained message queues.
    String retainAddress = MQTTUtil.convertMQTTAddressFilterToCoreRetain(address);
    BindingQueryResult bindingQueryResult = session.getServerSession().executeBindingQuery(new SimpleString(retainAddress));
    // Iterate over all matching retain queues and add the head message to the original queue.
    for (SimpleString retainedQueueName : bindingQueryResult.getQueueNames()) {
        Queue retainedQueue = session.getServer().locateQueue(retainedQueueName);
        synchronized (this) {
            Iterator<MessageReference> i = retainedQueue.iterator();
            if (i.hasNext()) {
                ServerMessage message = i.next().getMessage().copy(session.getServer().getStorageManager().generateID());
                queue.addTail(message.createReference(queue), true);
            }
        }
    }
}

22. MQTTRetainMessageManager#handleRetainedMessage()

Project: activemq-artemis
File: MQTTRetainMessageManager.java
/**
    * FIXME
    * Retained messages should be handled in the core API.  There is currently no support for retained messages
    * at the time of writing.  Instead we handle retained messages here.  This method will create a new queue for
    * every address that is used to store retained messages.  THere should only ever be one message in the retained
    * message queue.  When a new subscription is created the queue should be browsed and the message copied onto
    * the subscription queue for the consumer.  When a new retained message is received the message will be sent to
    * the retained queue and the previous retain message consumed to remove it from the queue.
    */
void handleRetainedMessage(ServerMessage message, String address, boolean reset) throws Exception {
    SimpleString retainAddress = new SimpleString(MQTTUtil.convertMQTTAddressFilterToCoreRetain(address));
    Queue queue = session.getServer().locateQueue(retainAddress);
    if (queue == null) {
        queue = session.getServerSession().createQueue(retainAddress, retainAddress, null, false, true);
    }
    // Set the address of this message to the retained queue.
    message.setAddress(retainAddress);
    Iterator<MessageReference> iterator = queue.iterator();
    synchronized (iterator) {
        if (iterator.hasNext()) {
            Long messageId = iterator.next().getMessage().getMessageID();
            queue.deleteReference(messageId);
        }
        if (!reset) {
            session.getServerSession().send(message.copy(), true);
        }
    }
}

23. DirectDeliverTest#testDirectDeliver()

Project: activemq-artemis
File: DirectDeliverTest.java
@Test
public void testDirectDeliver() throws Exception {
    final String foo = "foo";
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession();
    session.createQueue(foo, foo);
    Binding binding = server.getPostOffice().getBinding(new SimpleString(foo));
    Queue queue = (Queue) binding.getBindable();
    assertTrue(queue.isDirectDeliver());
    ClientProducer prod = session.createProducer(foo);
    ClientConsumer cons = session.createConsumer(foo);
    final int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        ClientMessage msg = session.createMessage(true);
        prod.send(msg);
    }
    queue.flushExecutor();
    //Consumer is not started so should go queued
    assertFalse(queue.isDirectDeliver());
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage msg = cons.receive(10000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    Thread.sleep((long) (QueueImpl.CHECK_QUEUE_SIZE_PERIOD * 1.5));
    //Add another message, should go direct
    ClientMessage msg = session.createMessage(true);
    prod.send(msg);
    queue.flushExecutor();
    assertTrue(queue.isDirectDeliver());
    //Send some more
    for (int i = 0; i < numMessages; i++) {
        msg = session.createMessage(true);
        prod.send(msg);
    }
    for (int i = 0; i < numMessages + 1; i++) {
        msg = cons.receive(10000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    assertTrue(queue.isDirectDeliver());
    session.stop();
    for (int i = 0; i < numMessages; i++) {
        msg = session.createMessage(true);
        prod.send(msg);
    }
    assertFalse(queue.isDirectDeliver());
}

24. SendReceiveMultiThreadTest#testMultipleWrites()

Project: activemq-artemis
File: SendReceiveMultiThreadTest.java
@Test
public void testMultipleWrites() throws Exception {
    deleteDirectory(new File(DIRECTORY));
    ActiveMQServer server = createServer(true);
    server.getConfiguration().setJournalFileSize(10 * 1024 * 1024);
    server.getConfiguration().setJournalMinFiles(2);
    server.getConfiguration().setJournalCompactMinFiles(ActiveMQDefaultConfiguration.getDefaultJournalCompactMinFiles());
    server.getConfiguration().setJournalCompactPercentage(ActiveMQDefaultConfiguration.getDefaultJournalCompactPercentage());
    server.getConfiguration().setJournalType(JournalType.ASYNCIO);
    server.getConfiguration().addAcceptorConfiguration("core", DefaultConnectionProperties.DEFAULT_BROKER_BIND_URL);
    server.getConfiguration().setJournalDirectory(DIRECTORY + "/journal");
    server.getConfiguration().setBindingsDirectory(DIRECTORY + "/bindings");
    server.getConfiguration().setPagingDirectory(DIRECTORY + "/paging");
    server.getConfiguration().setLargeMessagesDirectory(DIRECTORY + "/largemessage");
    server.getConfiguration().setJournalMaxIO_AIO(200);
    // TODO Setup Acceptors
    server.start();
    Queue queue = server.createQueue(SimpleString.toSimpleString("jms.queue.performanceQueue"), SimpleString.toSimpleString("jms.queue.performanceQueue"), null, true, false);
    Queue queue2 = server.createQueue(SimpleString.toSimpleString("jms.queue.stationaryQueue"), SimpleString.toSimpleString("jms.queue.stationaryQueue"), null, true, false);
    MyThread[] threads = new MyThread[NUMBER_OF_THREADS];
    ConsumerThread[] cthreads = new ConsumerThread[NUMBER_OF_THREADS];
    final CountDownLatch alignFlag = new CountDownLatch(NUMBER_OF_THREADS);
    final CountDownLatch startFlag = new CountDownLatch(1);
    final CountDownLatch finishFlag = new CountDownLatch(NUMBER_OF_THREADS);
    cf = new ActiveMQConnectionFactory();
    Thread slowSending = new Thread() {

        @Override
        public void run() {
            Connection conn = null;
            try {
                conn = cf.createConnection();
                Session session = conn.createSession(true, Session.SESSION_TRANSACTED);
                MessageProducer producer = session.createProducer(ActiveMQJMSClient.createQueue("stationaryQueue"));
                conn.start();
                MessageConsumer consumer = session.createConsumer(ActiveMQJMSClient.createQueue("stationaryQueue"));
                while (true) {
                    for (int i = 0; i < 10; i++) {
                        System.out.println("stationed message");
                        producer.send(session.createTextMessage("stationed"));
                        session.commit();
                        Thread.sleep(1000);
                    }
                    for (int i = 0; i < 10; i++) {
                        consumer.receive(5000);
                        session.commit();
                        System.out.println("Receiving stationed");
                        Thread.sleep(1000);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    conn.close();
                } catch (Exception ignored) {
                }
            }
        }
    };
    slowSending.start();
    destination = ActiveMQJMSClient.createQueue("performanceQueue");
    for (int i = 0; i < threads.length; i++) {
        threads[i] = new MyThread("sender::" + i, NUMBER_OF_MESSAGES, alignFlag, startFlag, finishFlag);
        cthreads[i] = new ConsumerThread(NUMBER_OF_MESSAGES);
    }
    for (ConsumerThread t : cthreads) {
        t.start();
    }
    for (MyThread t : threads) {
        t.start();
    }
    Assert.assertEquals(NUMBER_OF_THREADS, queue.getConsumerCount());
    alignFlag.await();
    long startTime = System.currentTimeMillis();
    startFlag.countDown();
    // I'm using a countDown to avoid measuring time spent on thread context from join.
    // i.e. i want to measure as soon as the loops are done
    finishFlag.await();
    long endtime = System.currentTimeMillis();
    receivedLatch.await();
    long endTimeConsuming = System.currentTimeMillis();
    for (ConsumerThread t : cthreads) {
        t.join();
        Assert.assertEquals(0, t.errors);
    }
    for (MyThread t : threads) {
        t.join();
        Assert.assertEquals(0, t.errors.get());
    }
    slowSending.interrupt();
    slowSending.join();
    server.stop();
    System.out.println("Time on sending:: " + (endtime - startTime));
    System.out.println("Time on consuming:: " + (endTimeConsuming - startTime));
}

25. 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);
}

26. ActiveMQClusteredTest#testRebalanceInternal()

Project: activemq-artemis
File: ActiveMQClusteredTest.java
public void testRebalanceInternal(int reconnectAttempts) throws Exception {
    final int CONSUMER_COUNT = 10;
    secondaryJmsServer.createQueue(true, MDBQUEUE, null, true, "/jms/" + MDBQUEUE);
    ActiveMQResourceAdapter qResourceAdapter = newResourceAdapter();
    MyBootstrapContext ctx = new MyBootstrapContext();
    qResourceAdapter.start(ctx);
    ActiveMQActivationSpec spec = new ActiveMQActivationSpec();
    spec.setResourceAdapter(qResourceAdapter);
    spec.setUseJNDI(false);
    spec.setDestinationType("javax.jms.Queue");
    spec.setDestination(MDBQUEUE);
    spec.setRebalanceConnections(true);
    spec.setMaxSession(CONSUMER_COUNT);
    spec.setSetupAttempts(5);
    spec.setSetupInterval(200);
    spec.setReconnectAttempts(reconnectAttempts);
    // if this isn't true then the toplogy listener won't get nodeDown notifications
    spec.setHA(true);
    // if this isn't set then it may take a long time for tearDown to occur on the MDB connection
    spec.setCallTimeout(500L);
    qResourceAdapter.setConnectorClassName(INVM_CONNECTOR_FACTORY);
    CountDownLatch latch = new CountDownLatch(1);
    DummyMessageEndpoint endpoint = new DummyMessageEndpoint(latch);
    DummyMessageEndpointFactory endpointFactory = new DummyMessageEndpointFactory(endpoint, false);
    qResourceAdapter.endpointActivation(endpointFactory, spec);
    Queue primaryQueue = server.locateQueue(MDBQUEUEPREFIXEDSIMPLE);
    Queue secondaryQueue = secondaryServer.locateQueue(MDBQUEUEPREFIXEDSIMPLE);
    assertTrue(primaryQueue.getConsumerCount() < CONSUMER_COUNT);
    assertTrue(secondaryQueue.getConsumerCount() < CONSUMER_COUNT);
    assertTrue(primaryQueue.getConsumerCount() + secondaryQueue.getConsumerCount() == CONSUMER_COUNT);
    ClientSession session = addClientSession(locator.createSessionFactory().createSession());
    ClientProducer clientProducer = session.createProducer(MDBQUEUEPREFIXED);
    ClientMessage message = session.createMessage(true);
    message.getBodyBuffer().writeString("test");
    clientProducer.send(message);
    latch.await(5, TimeUnit.SECONDS);
    assertNotNull(endpoint.lastMessage);
    assertEquals(endpoint.lastMessage.getCoreMessage().getBodyBuffer().readString(), "test");
    for (int i = 0; i < 10; i++) {
        secondaryServer.stop();
        long mark = System.currentTimeMillis();
        long timeout = 5000;
        while (primaryQueue.getConsumerCount() < CONSUMER_COUNT && (System.currentTimeMillis() - mark) < timeout) {
            Thread.sleep(100);
        }
        assertTrue(primaryQueue.getConsumerCount() == CONSUMER_COUNT);
        secondaryServer.start();
        waitForServerToStart(secondaryServer);
        secondaryQueue = secondaryServer.locateQueue(MDBQUEUEPREFIXEDSIMPLE);
        mark = System.currentTimeMillis();
        while (((primaryQueue.getConsumerCount() + secondaryQueue.getConsumerCount()) < (CONSUMER_COUNT) || primaryQueue.getConsumerCount() == CONSUMER_COUNT) && (System.currentTimeMillis() - mark) <= timeout) {
            Thread.sleep(100);
        }
        assertTrue(primaryQueue.getConsumerCount() < CONSUMER_COUNT);
        assertTrue(secondaryQueue.getConsumerCount() < CONSUMER_COUNT);
        assertTrue(primaryQueue.getConsumerCount() + secondaryQueue.getConsumerCount() == CONSUMER_COUNT);
    }
    qResourceAdapter.endpointDeactivation(endpointFactory, spec);
    qResourceAdapter.stop();
}

27. SessionTest#flushQueue()

Project: activemq-artemis
File: SessionTest.java
private void flushQueue() throws Exception {
    Queue queue = server.locateQueue(SimpleString.toSimpleString(queueName));
    assertNotNull(queue);
    queue.flushExecutor();
}

28. PagingTest#testMissingTXEverythingAcked()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testMissingTXEverythingAcked() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 5000;
    final int numberOfTX = 10;
    final int messagesPerTX = numberOfMessages / numberOfTX;
    try {
        locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
        sf = createSessionFactory(locator);
        ClientSession session = sf.createSession(false, false, false);
        session.createQueue(ADDRESS.toString(), "q1", true);
        session.createQueue(ADDRESS.toString(), "q2", true);
        ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
        ClientMessage message = null;
        byte[] body = new byte[MESSAGE_SIZE];
        ByteBuffer bb = ByteBuffer.wrap(body);
        for (int j = 1; j <= MESSAGE_SIZE; j++) {
            bb.put(getSamplebyte(j));
        }
        for (int i = 0; i < numberOfMessages; i++) {
            message = session.createMessage(true);
            ActiveMQBuffer bodyLocal = message.getBodyBuffer();
            bodyLocal.writeBytes(body);
            message.putIntProperty(new SimpleString("id"), i);
            producer.send(message);
            if (i % messagesPerTX == 0) {
                session.commit();
            }
        }
        session.commit();
        session.close();
    } finally {
        try {
            server.stop();
        } catch (Throwable ignored) {
        }
    }
    ArrayList<RecordInfo> records = new ArrayList<>();
    List<PreparedTransactionInfo> list = new ArrayList<>();
    JournalImpl jrn = new JournalImpl(config.getJournalFileSize(), 2, 2, 0, 0, new NIOSequentialFileFactory(server.getConfiguration().getJournalLocation(), 1), "activemq-data", "amq", 1);
    jrn.start();
    jrn.load(records, list, null);
    // Delete everything from the journal
    for (RecordInfo info : records) {
        if (!info.isUpdate && info.getUserRecordType() != JournalRecordIds.PAGE_CURSOR_COUNTER_VALUE && info.getUserRecordType() != JournalRecordIds.PAGE_CURSOR_COUNTER_INC && info.getUserRecordType() != JournalRecordIds.PAGE_CURSOR_COMPLETE) {
            jrn.appendDeleteRecord(info.id, false);
        }
    }
    jrn.stop();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    ClientSessionFactory csf = createSessionFactory(locator);
    ClientSession sess = csf.createSession();
    sess.start();
    ClientConsumer cons = sess.createConsumer("q1");
    assertNull(cons.receiveImmediate());
    ClientConsumer cons2 = sess.createConsumer("q2");
    assertNull(cons2.receiveImmediate());
    Queue q1 = server.locateQueue(new SimpleString("q1"));
    Queue q2 = server.locateQueue(new SimpleString("q2"));
    q1.getPageSubscription().cleanupEntries(false);
    q2.getPageSubscription().cleanupEntries(false);
    PageCursorProvider provider = q1.getPageSubscription().getPagingStore().getCursorProvider();
    provider.cleanup();
    waitForNotPaging(q1);
    sess.close();
}

29. PagingTest#testMoveExpire()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testMoveExpire() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = // disable compact
    createDefaultInVMConfig().setJournalDirectory(getJournalDir()).setJournalSyncNonTransactional(false).setJournalCompactMinFiles(0).setMessageExpiryScanPeriod(500);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(PAGE_SIZE).setMaxSizeBytes(PAGE_MAX).setExpiryAddress(new SimpleString("EXP")).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    server.getAddressSettingsRepository().clear();
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    server.start();
    final int numberOfMessages = 5000;
    locator = createInVMNonHALocator().setConsumerWindowSize(10 * 1024 * 1024).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    ClientSessionFactory sf = locator.createSessionFactory();
    ClientSession session = sf.createSession(false, false, false);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    session.createQueue("EXP", "EXP", null, true);
    Queue queue1 = server.locateQueue(ADDRESS);
    Queue qEXP = server.locateQueue(new SimpleString("EXP"));
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    final int MESSAGE_SIZE = 1024;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage message = session.createMessage(true);
        if (i < 1000) {
            message.setExpiration(System.currentTimeMillis() + 1000);
        }
        message.putIntProperty("tst-count", i);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    producer.close();
    for (long timeout = System.currentTimeMillis() + 60000; timeout > System.currentTimeMillis() && getMessageCount(qEXP) < 1000; ) {
        System.out.println("count = " + getMessageCount(qEXP));
        Thread.sleep(100);
    }
    assertEquals(1000, getMessageCount(qEXP));
    session.start();
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    for (int i = 0; i < numberOfMessages - 1000; i++) {
        ClientMessage message = consumer.receive(5000);
        assertNotNull(message);
        message.acknowledge();
        assertTrue(message.getIntProperty("tst-count") >= 1000);
    }
    session.commit();
    assertNull(consumer.receiveImmediate());
    for (long timeout = System.currentTimeMillis() + 5000; timeout > System.currentTimeMillis() && getMessageCount(queue1) != 0; ) {
        Thread.sleep(100);
    }
    assertEquals(0, getMessageCount(queue1));
    consumer.close();
    consumer = session.createConsumer("EXP");
    for (int i = 0; i < 1000; i++) {
        ClientMessage message = consumer.receive(5000);
        assertNotNull(message);
        message.acknowledge();
        assertTrue(message.getIntProperty("tst-count") < 1000);
    }
    assertNull(consumer.receiveImmediate());
    // This is just to hold some messages as being delivered
    ClientConsumerInternal cons = (ClientConsumerInternal) session.createConsumer(ADDRESS);
    session.commit();
    producer.close();
    session.close();
    server.stop();
}

30. PagingOrderTest#testPageCounter2()

Project: activemq-artemis
File: PagingOrderTest.java
@Test
public void testPageCounter2() throws Throwable {
    boolean persistentMessages = true;
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    ActiveMQServer server = createServer(true, config, PAGE_SIZE, PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int messageSize = 1024;
    final int numberOfMessages = 500;
    ServerLocator locator = createInVMNonHALocator().setClientFailureCheckPeriod(1000).setConnectionTTL(2000).setReconnectAttempts(0).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true).setConsumerWindowSize(1024 * 1024);
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    Queue q1 = server.createQueue(ADDRESS, ADDRESS, null, true, false);
    Queue q2 = server.createQueue(ADDRESS, new SimpleString("inactive"), null, true, false);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    byte[] body = new byte[messageSize];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= messageSize; j++) {
        bb.put(getSamplebyte(j));
    }
    final AtomicInteger errors = new AtomicInteger(0);
    Thread t1 = new Thread() {

        @Override
        public void run() {
            try {
                ServerLocator sl = createInVMNonHALocator();
                ClientSessionFactory sf = sl.createSessionFactory();
                ClientSession sess = sf.createSession(true, true, 0);
                sess.start();
                ClientConsumer cons = sess.createConsumer(ADDRESS);
                for (int i = 0; i < 100; i++) {
                    ClientMessage msg = cons.receive(5000);
                    assertNotNull(msg);
                    assertEquals(i, msg.getIntProperty("id").intValue());
                    msg.acknowledge();
                }
                sess.close();
                sl.close();
            } catch (Throwable e) {
                e.printStackTrace();
                errors.incrementAndGet();
            }
        }
    };
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage message = session.createMessage(persistentMessages);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
        if (i % 20 == 0) {
            session.commit();
        }
    }
    session.commit();
    t1.start();
    t1.join();
    assertEquals(0, errors.get());
    long timeout = System.currentTimeMillis() + 10000;
    while (numberOfMessages - 100 != getMessageCount(q1) && System.currentTimeMillis() < timeout) {
        Thread.sleep(500);
    }
    assertEquals(numberOfMessages, getMessageCount(q2));
    assertEquals(numberOfMessages, getMessagesAdded(q2));
    assertEquals(numberOfMessages - 100, getMessageCount(q1));
}

31. PagingOrderTest#testPageCounter()

Project: activemq-artemis
File: PagingOrderTest.java
@Test
public void testPageCounter() throws Throwable {
    boolean persistentMessages = true;
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    ActiveMQServer server = createServer(true, config, PAGE_SIZE, PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int messageSize = 1024;
    final int numberOfMessages = 500;
    ServerLocator locator = createInVMNonHALocator().setClientFailureCheckPeriod(1000).setConnectionTTL(2000).setReconnectAttempts(0).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true).setConsumerWindowSize(1024 * 1024);
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    Queue q1 = server.createQueue(ADDRESS, ADDRESS, null, true, false);
    Queue q2 = server.createQueue(ADDRESS, new SimpleString("inactive"), null, true, false);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    byte[] body = new byte[messageSize];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= messageSize; j++) {
        bb.put(getSamplebyte(j));
    }
    final AtomicInteger errors = new AtomicInteger(0);
    Thread t1 = new Thread() {

        @Override
        public void run() {
            try {
                ServerLocator sl = createInVMNonHALocator();
                ClientSessionFactory sf = sl.createSessionFactory();
                ClientSession sess = sf.createSession(true, true, 0);
                sess.start();
                ClientConsumer cons = sess.createConsumer(ADDRESS);
                for (int i = 0; i < numberOfMessages; i++) {
                    ClientMessage msg = cons.receive(5000);
                    assertNotNull(msg);
                    assertEquals(i, msg.getIntProperty("id").intValue());
                    msg.acknowledge();
                }
                assertNull(cons.receiveImmediate());
                sess.close();
                sl.close();
            } catch (Throwable e) {
                e.printStackTrace();
                errors.incrementAndGet();
            }
        }
    };
    t1.start();
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage message = session.createMessage(persistentMessages);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
        if (i % 20 == 0) {
            session.commit();
        }
    }
    session.commit();
    t1.join();
    assertEquals(0, errors.get());
    assertEquals(numberOfMessages, getMessageCount(q2));
    assertEquals(numberOfMessages, getMessagesAdded(q2));
    assertEquals(0, getMessageCount(q1));
    assertEquals(numberOfMessages, getMessagesAdded(q1));
    session.close();
    sf.close();
    locator.close();
    server.stop();
    server.start();
    Bindings bindings = server.getPostOffice().getBindingsForAddress(ADDRESS);
    q1 = null;
    q2 = null;
    for (Binding bind : bindings.getBindings()) {
        if (bind instanceof LocalQueueBinding) {
            LocalQueueBinding qb = (LocalQueueBinding) bind;
            if (qb.getQueue().getName().equals(ADDRESS)) {
                q1 = qb.getQueue();
            }
            if (qb.getQueue().getName().equals(new SimpleString("inactive"))) {
                q2 = qb.getQueue();
            }
        }
    }
    assertNotNull(q1);
    assertNotNull(q2);
    assertEquals("q2 msg count", numberOfMessages, getMessageCount(q2));
    assertEquals("q2 msgs added", numberOfMessages, getMessagesAdded(q2));
    assertEquals("q1 msg count", 0, getMessageCount(q1));
    // 0, since nothing was sent to the queue after the server was restarted
    assertEquals("q1 msgs added", 0, getMessagesAdded(q1));
}

32. ExpiryLargeMessageTest#testExpiryMessagesThenDLQ()

Project: activemq-artemis
File: ExpiryLargeMessageTest.java
// Attributes ----------------------------------------------------
// Static --------------------------------------------------------
// Constructors --------------------------------------------------
// Public --------------------------------------------------------
@Test
public void testExpiryMessagesThenDLQ() throws Exception {
    ActiveMQServer server = createServer(true);
    server.getConfiguration().setMessageExpiryScanPeriod(600000);
    AddressSettings setting = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setMaxDeliveryAttempts(5).setMaxSizeBytes(50 * 1024).setPageSizeBytes(10 * 1024).setExpiryAddress(EXPIRY).setDeadLetterAddress(DLQ);
    server.getAddressSettingsRepository().addMatch(MY_QUEUE.toString(), setting);
    server.getAddressSettingsRepository().addMatch(EXPIRY.toString(), setting);
    server.start();
    server.createQueue(EXPIRY, EXPIRY, null, true, false);
    server.createQueue(DLQ, DLQ, null, true, false);
    server.createQueue(MY_QUEUE, MY_QUEUE, null, true, false);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = addSessionFactory(createSessionFactory(locator));
    ClientSession session = sf.createSession(true, true, 0);
    byte[] bufferSample = new byte[messageSize];
    for (int i = 0; i < bufferSample.length; i++) {
        bufferSample[i] = getSamplebyte(i);
    }
    ClientProducer producer = session.createProducer(MY_QUEUE);
    long timeToExpiry = System.currentTimeMillis() + 1000;
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage message = session.createMessage(true);
        message.putIntProperty("count", i);
        // Send a few regular messages first, then all is just large messages
        if (i % 2 == 0) {
            message.putBooleanProperty("tst-large", false);
            message.getBodyBuffer().writeBytes(bufferSample);
        } else {
            message.putBooleanProperty("tst-large", true);
            message.setBodyInputStream(createFakeLargeStream(messageSize));
        }
        message.setExpiration(timeToExpiry);
        producer.send(message);
    }
    session.close();
    server.stop();
    server.start();
    Queue queueExpiry = server.locateQueue(EXPIRY);
    Queue myQueue = server.locateQueue(MY_QUEUE);
    sf = createSessionFactory(locator);
    Thread.sleep(1500);
    long timeout = System.currentTimeMillis() + 5000;
    while (timeout > System.currentTimeMillis() && getMessageCount(queueExpiry) != numberOfMessages) {
        // What the Expiry Scan would be doing
        myQueue.expireReferences();
        Thread.sleep(50);
    }
    assertEquals(50, getMessageCount(queueExpiry));
    session = sf.createSession(false, false);
    ClientConsumer cons = session.createConsumer(EXPIRY);
    session.start();
    // Consume half of the messages to make sure all the messages are paging (on the second try)
    for (int i = 0; i < numberOfMessages / 2; i++) {
        ClientMessage msg = cons.receive(5000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    session.commit();
    cons.close();
    for (int rep = 0; rep < 6; rep++) {
        cons = session.createConsumer(EXPIRY);
        session.start();
        log.info("Trying " + rep);
        for (int i = 0; i < numberOfMessages / 2; i++) {
            ClientMessage message = cons.receive(5000);
            assertNotNull(message);
            if (i % 10 == 0) {
                System.out.println("Received " + i);
            }
            for (int location = 0; location < messageSize; location++) {
                assertEquals(getSamplebyte(location), message.getBodyBuffer().readByte());
            }
            message.acknowledge();
        }
        session.rollback();
        cons.close();
        session.close();
        sf.close();
        if (rep == 0) {
            // restart the server at the first try
            server.stop();
            server.start();
        }
        sf = createSessionFactory(locator);
        session = sf.createSession(false, false);
        session.start();
    }
    cons = session.createConsumer(EXPIRY);
    session.start();
    assertNull(cons.receiveImmediate());
    cons.close();
    session.close();
    sf.close();
    for (int rep = 0; rep < 2; rep++) {
        sf = createSessionFactory(locator);
        session = sf.createSession(false, false);
        cons = session.createConsumer(DLQ);
        session.start();
        for (int i = 0; i < numberOfMessages / 2; i++) {
            ClientMessage message = cons.receive(5000);
            assertNotNull(message);
            if (i % 10 == 0) {
                System.out.println("Received " + i);
            }
            for (int location = 0; location < messageSize; location++) {
                assertEquals(getSamplebyte(location), message.getBodyBuffer().readByte());
            }
            message.acknowledge();
        }
        if (rep == 0) {
            session.rollback();
            session.close();
            sf.close();
            server.stop();
            server.start();
        }
    }
    session.commit();
    assertNull(cons.receiveImmediate());
    session.close();
    sf.close();
    locator.close();
    validateNoFilesOnLargeDir();
}

33. CommitRollbackTest#testReceiveWithRollbackMultipleConsumersDifferentQueues()

Project: activemq-artemis
File: CommitRollbackTest.java
@Test
public void testReceiveWithRollbackMultipleConsumersDifferentQueues() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientSession session = cf.createSession(false, false, false);
    sendSession.createQueue(addressA, queueA, false);
    sendSession.createQueue(addressB, queueB, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    ClientConsumer cc = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
        cp2.send(sendSession.createMessage(false));
    }
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = cc.receive(5000);
        Assert.assertNotNull(cm);
        cm.acknowledge();
        cm = cc2.receive(5000);
        Assert.assertNotNull(cm);
        cm.acknowledge();
    }
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Queue q2 = (Queue) server.getPostOffice().getBinding(queueB).getBindable();
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    cc.close();
    cc2.close();
    session.rollback();
    Assert.assertEquals(0, q2.getDeliveringCount());
    Assert.assertEquals(numMessages, getMessageCount(q));
    Assert.assertEquals(0, q2.getDeliveringCount());
    Assert.assertEquals(numMessages, getMessageCount(q));
    sendSession.close();
    session.close();
}

34. OrphanedConsumerTest#internalTestOrphanedConsumers()

Project: activemq-artemis
File: OrphanedConsumerTest.java
/**
    * @param useManagement true = it will use a management operation to make the connection failure, false through ping
    * @throws Exception
    */
private void internalTestOrphanedConsumers(boolean useManagement) throws Exception {
    final int NUMBER_OF_MESSAGES = 2;
    server = createServer(true, true);
    server.start();
    staticServer = server;
    // We are not interested on consumer-window-size on this test
    // We want that every message is delivered
    // as we asserting for number of consumers available and round-robin on delivery
    locator.setConsumerWindowSize(-1).setBlockOnNonDurableSend(false).setBlockOnDurableSend(false).setBlockOnAcknowledge(true).setConnectionTTL(1000).setClientFailureCheckPeriod(100).setReconnectAttempts(0);
    ClientSessionFactoryImpl sf = (ClientSessionFactoryImpl) createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true, 0);
    session.createQueue("queue", "queue1", true);
    session.createQueue("queue", "queue2", true);
    ClientProducer prod = session.createProducer("queue");
    ClientConsumer consumer = session.createConsumer("queue1");
    ClientConsumer consumer2 = session.createConsumer("queue2");
    Queue queue1 = server.locateQueue(new SimpleString("queue1"));
    Queue queue2 = server.locateQueue(new SimpleString("queue2"));
    session.start();
    if (!useManagement) {
        sf.stopPingingAfterOne();
        for (long timeout = System.currentTimeMillis() + 6000; timeout > System.currentTimeMillis() && server.getConnectionCount() != 0; ) {
            Thread.sleep(100);
        }
        // an extra second to avoid races of something closing the session while we are asserting it
        Thread.sleep(1000);
    } else {
        server.getActiveMQServerControl().closeConnectionsForAddress("127.0.0.1");
    }
    if (verification != null) {
        throw verification;
    }
    assertEquals(0, queue1.getConsumerCount());
    assertEquals(0, queue2.getConsumerCount());
    setConditionActive(false);
    locator = internalCreateNonHALocator(true).setBlockOnNonDurableSend(false).setBlockOnDurableSend(false).setBlockOnAcknowledge(true).setReconnectAttempts(0).setConsumerWindowSize(-1);
    sf = (ClientSessionFactoryImpl) locator.createSessionFactory();
    session = sf.createSession(true, true, 0);
    session.start();
    prod = session.createProducer("queue");
    for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
        ClientMessage message = session.createMessage(true);
        message.putIntProperty("i", i);
        prod.send(message);
    }
    consumer = session.createConsumer("queue1");
    consumer2 = session.createConsumer("queue2");
    for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
        assertNotNull(consumer.receive(5000));
        assertNotNull(consumer2.receive(5000));
    }
    session.close();
}

35. ActiveMQServerImpl#destroyQueue()

Project: activemq-artemis
File: ActiveMQServerImpl.java
@Override
public void destroyQueue(final SimpleString queueName, final SecurityAuth session, final boolean checkConsumerCount, final boolean removeConsumers) throws Exception {
    addressSettingsRepository.clearCache();
    Binding binding = postOffice.getBinding(queueName);
    if (binding == null) {
        throw ActiveMQMessageBundle.BUNDLE.noSuchQueue(queueName);
    }
    SimpleString address = binding.getAddress();
    Queue queue = (Queue) binding.getBindable();
    // This check is only valid if checkConsumerCount == true
    if (checkConsumerCount && queue.getConsumerCount() != 0) {
        throw ActiveMQMessageBundle.BUNDLE.cannotDeleteQueue(queue.getName(), queueName, binding.getClass().getName());
    }
    if (session != null) {
        if (queue.isDurable()) {
            // make sure the user has privileges to delete this queue
            securityStore.check(address, CheckType.DELETE_DURABLE_QUEUE, session);
        } else {
            securityStore.check(address, CheckType.DELETE_NON_DURABLE_QUEUE, session);
        }
    }
    queue.deleteQueue(removeConsumers);
    callPostQueueDeletionCallbacks(address, queueName);
}

36. MQTTSubscriptionManager#removeSubscription()

Project: activemq-artemis
File: MQTTSubscriptionManager.java
// FIXME: Do we need this synchronzied?
private synchronized void removeSubscription(String address) throws Exception {
    ServerConsumer consumer = consumers.get(address);
    String internalAddress = MQTTUtil.convertMQTTAddressFilterToCore(address);
    SimpleString internalQueueName = getQueueNameForTopic(internalAddress);
    Queue queue = session.getServer().locateQueue(internalQueueName);
    queue.deleteQueue(true);
    session.getSessionState().removeSubscription(address);
    consumers.remove(address);
    consumerQoSLevels.remove(consumer.getID());
}

37. PagingCounterTest#testRestartCounter()

Project: activemq-artemis
File: PagingCounterTest.java
@Test
public void testRestartCounter() throws Exception {
    Queue queue = server.createQueue(new SimpleString("A1"), new SimpleString("A1"), null, true, false);
    PageSubscriptionCounter counter = locateCounter(queue);
    StorageManager storage = server.getStorageManager();
    Transaction tx = new TransactionImpl(server.getStorageManager());
    counter.increment(tx, 1);
    assertEquals(0, counter.getValue());
    tx.commit();
    storage.waitOnOperations();
    assertEquals(1, counter.getValue());
    sl.close();
    server.stop();
    server = newActiveMQServer();
    server.start();
    queue = server.locateQueue(new SimpleString("A1"));
    assertNotNull(queue);
    counter = locateCounter(queue);
    assertEquals(1, counter.getValue());
}

38. QueueControlTest#testListDeliveringMessages()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testListDeliveringMessages() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    int intValue = RandomUtil.randomInt();
    session.createQueue(address, queue, null, false);
    Queue srvqueue = server.locateQueue(queue);
    QueueControl queueControl = createManagementControl(address, queue);
    ClientProducer producer = session.createProducer(address);
    ClientMessage message = session.createMessage(false);
    message.putIntProperty(new SimpleString("key"), intValue);
    producer.send(message);
    producer.send(session.createMessage(false));
    ClientConsumer consumer = session.createConsumer(queue);
    session.start();
    ClientMessage msgRec = consumer.receive(5000);
    assertNotNull(msgRec);
    assertEquals(msgRec.getIntProperty("key").intValue(), intValue);
    ClientSessionFactory sf2 = createSessionFactory(locator);
    ClientSession session2 = sf2.createSession(false, true, false);
    ClientConsumer consumer2 = session2.createConsumer(queue);
    session2.start();
    ClientMessage msgRec2 = consumer2.receive(5000);
    assertNotNull(msgRec2);
    assertEquals(2, srvqueue.getDeliveringCount());
    assertEquals(2, srvqueue.getConsumerCount());
    System.out.println(queueControl.listDeliveringMessagesAsJSON());
    Map<String, Map<String, Object>[]> deliveringMap = queueControl.listDeliveringMessages();
    assertEquals(2, deliveringMap.size());
    consumer.close();
    consumer2.close();
    session.deleteQueue(queue);
}

39. PagingFailoverTest#testExpireMessage()

Project: activemq-artemis
File: PagingFailoverTest.java
@Test
public void testExpireMessage() throws Exception {
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setReconnectAttempts(-1);
    ClientSessionFactoryInternal sf = createSessionFactoryAndWaitForTopology(locator, 2);
    session = sf.createSession(true, true, 0);
    session.createQueue(PagingFailoverTest.ADDRESS, PagingFailoverTest.ADDRESS, true);
    ClientProducer prod = session.createProducer(PagingFailoverTest.ADDRESS);
    final int TOTAL_MESSAGES = 1000;
    for (int i = 0; i < TOTAL_MESSAGES; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.putIntProperty(new SimpleString("key"), i);
        msg.setExpiration(System.currentTimeMillis() + 1000);
        prod.send(msg);
    }
    crash(session);
    session.close();
    Queue queue = backupServer.getServer().locateQueue(ADDRESS);
    long timeout = System.currentTimeMillis() + 60000;
    while (timeout > System.currentTimeMillis() && queue.getPageSubscription().isPaging()) {
        Thread.sleep(100);
        // Simulating what would happen on expire
        queue.expireReferences();
    }
    Assert.assertFalse(queue.getPageSubscription().isPaging());
}

40. BackupSyncJournalTest#testReserveFileIdValuesOnBackup()

Project: activemq-artemis
File: BackupSyncJournalTest.java
@Test
public void testReserveFileIdValuesOnBackup() throws Exception {
    final int totalRounds = 50;
    createProducerSendSomeMessages();
    JournalImpl messageJournal = getMessageJournalFromServer(liveServer);
    for (int i = 0; i < totalRounds; i++) {
        messageJournal.forceMoveNextFile();
        sendMessages(session, producer, n_msgs);
    }
    Queue queue = liveServer.getServer().locateQueue(ADDRESS);
    PagingStore store = queue.getPageSubscription().getPagingStore();
    // what would make the verification on similar journal to fail after the recovery
    if (store.isPaging()) {
        store.forceAnotherPage();
    }
    backupServer.start();
    // Deliver messages with Backup in-sync
    waitForRemoteBackup(sessionFactory, BACKUP_WAIT_TIME, false, backupServer.getServer());
    final JournalImpl backupMsgJournal = getMessageJournalFromServer(backupServer);
    sendMessages(session, producer, n_msgs);
    // what would make the verification on similar journal to fail after the recovery
    if (store.isPaging()) {
        store.forceAnotherPage();
    }
    // Deliver messages with Backup up-to-date
    syncDelay.deliverUpToDateMsg();
    waitForRemoteBackup(sessionFactory, BACKUP_WAIT_TIME, true, backupServer.getServer());
    // SEND more messages, now with the backup replicating
    sendMessages(session, producer, n_msgs);
    // what would make the verification on similar journal to fail after the recovery
    if (store.isPaging()) {
        store.forceAnotherPage();
    }
    Set<Pair<Long, Integer>> liveIds = getFileIds(messageJournal);
    int size = messageJournal.getFileSize();
    PagingStore ps = liveServer.getServer().getPagingManager().getPageStore(ADDRESS);
    if (ps.getPageSizeBytes() == PAGE_SIZE) {
        assertTrue("isStarted", ps.isStarted());
        assertFalse("start paging should return false, because we expect paging to be running", ps.startPaging());
    }
    finishSyncAndFailover();
    assertEquals("file sizes must be the same", size, backupMsgJournal.getFileSize());
    Set<Pair<Long, Integer>> backupIds = getFileIds(backupMsgJournal);
    int total = 0;
    for (Pair<Long, Integer> pair : liveIds) {
        total += pair.getB();
    }
    int totalBackup = 0;
    for (Pair<Long, Integer> pair : backupIds) {
        totalBackup += pair.getB();
    }
    assertEquals("number of records must match ", total, totalBackup);
    // "+ 2": there two other calls that send N_MSGS.
    for (int i = 0; i < totalRounds + 3; i++) {
        receiveMsgsInRange(0, n_msgs);
    }
    assertNoMoreMessages();
}

41. BridgeReconnectTest#testDeliveringCountOnBridgeConnectionFailure()

Project: activemq-artemis
File: BridgeReconnectTest.java
@Test
public void testDeliveringCountOnBridgeConnectionFailure() throws Exception {
    server0 = createActiveMQServer(0, isNetty(), server0Params);
    TransportConfiguration server0tc = new TransportConfiguration(getConnector(), server0Params, "server0tc");
    server0.getConfiguration().setConnectorConfigurations(connectors);
    BridgeConfiguration bridgeConfiguration = createBridgeConfig();
    List<BridgeConfiguration> bridgeConfigs = new ArrayList<>();
    bridgeConfigs.add(bridgeConfiguration);
    server0.getConfiguration().setBridgeConfigurations(bridgeConfigs);
    CoreQueueConfiguration queueConfig0 = new CoreQueueConfiguration().setAddress(testAddress).setName(queueName);
    List<CoreQueueConfiguration> queueConfigs0 = new ArrayList<>();
    queueConfigs0.add(queueConfig0);
    server0.getConfiguration().setQueueConfigurations(queueConfigs0);
    CoreQueueConfiguration queueConfig1 = new CoreQueueConfiguration().setAddress(forwardAddress).setName(queueName);
    List<CoreQueueConfiguration> queueConfigs1 = new ArrayList<>();
    queueConfigs1.add(queueConfig1);
    server1.getConfiguration().setQueueConfigurations(queueConfigs1);
    startServers();
    locator = addServerLocator(ActiveMQClient.createServerLocatorWithHA(server0tc, server1tc));
    ClientSessionFactory csf0 = locator.createSessionFactory(server0tc);
    session0 = csf0.createSession(false, true, true);
    ClientSessionFactory csf1 = locator.createSessionFactory(server1tc);
    session1 = csf1.createSession(false, true, true);
    ClientProducer prod0 = session0.createProducer(testAddress);
    session1.start();
    Bridge bridge = server0.getClusterManager().getBridges().get(bridgeName);
    RemotingConnection forwardingConnection = getForwardingConnection(bridge);
    InVMConnector.failOnCreateConnection = true;
    InVMConnector.numberOfFailures = reconnectAttempts - 1;
    //forwardingConnection.fail(new ActiveMQNotConnectedException());
    final int numMessages = NUM_MESSAGES;
    SimpleString propKey = new SimpleString("propkey");
    final Queue queue = (Queue) server0.getPostOffice().getBinding(new SimpleString(queueName)).getBindable();
    System.out.println("DeliveringCount: " + queue.getDeliveringCount());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session0.createMessage(false);
        message.putIntProperty(propKey, i);
        prod0.send(message);
        if (i == 50) {
            forwardingConnection.fail(new ActiveMQException(ActiveMQExceptionType.UNBLOCKED));
        }
    }
    for (int i = 0; i < 100 && queue.getDeliveringCount() != 0; i++) {
        Thread.sleep(10);
    }
    System.out.println("Check.. DeliveringCount: " + queue.getDeliveringCount());
    assertEquals("Delivering count of a source queue should be zero on connection failure", 0, queue.getDeliveringCount());
    closeServers();
    assertNoMoreConnections();
}

42. SessionTest#testRollbackWithReceive()

Project: activemq-artemis
File: SessionTest.java
@Test
public void testRollbackWithReceive() throws Exception {
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);
    cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientProducer cp = sendSession.createProducer(queueName);
    ClientSession clientSession = cf.createSession(false, true, false);
    clientSession.createQueue(queueName, queueName, false);
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(queueName)).getBindable();
    Assert.assertEquals(10, getMessageCount(q));
    ClientConsumer cc = clientSession.createConsumer(queueName);
    clientSession.start();
    ClientMessage m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    clientSession.rollback();
    Assert.assertEquals(10, getMessageCount(q));
    clientSession.close();
    sendSession.close();
}

43. SessionTest#testCommitWithReceive()

Project: activemq-artemis
File: SessionTest.java
@Test
public void testCommitWithReceive() throws Exception {
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);
    cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientProducer cp = sendSession.createProducer(queueName);
    ClientSession clientSession = cf.createSession(false, true, false);
    clientSession.createQueue(queueName, queueName, false);
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    cp.send(clientSession.createMessage(false));
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(queueName)).getBindable();
    Assert.assertEquals(10, getMessageCount(q));
    ClientConsumer cc = clientSession.createConsumer(queueName);
    clientSession.start();
    ClientMessage m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    m = cc.receive(5000);
    Assert.assertNotNull(m);
    m.acknowledge();
    clientSession.commit();
    Assert.assertEquals(0, getMessageCount(q));
    clientSession.close();
    sendSession.close();
}

44. SessionCreateAndDeleteQueueTest#testcreateWithFilter()

Project: activemq-artemis
File: SessionCreateAndDeleteQueueTest.java
@Test
public void testcreateWithFilter() throws Exception {
    ClientSession session = createSessionFactory(locator).createSession(false, true, true);
    SimpleString filterString = new SimpleString("x=y");
    session.createQueue(address, queueName, filterString, false);
    Binding binding = server.getPostOffice().getBinding(queueName);
    Queue q = (Queue) binding.getBindable();
    Assert.assertEquals(q.getFilter().getFilterString(), filterString);
    session.close();
}

45. SessionCreateAndDeleteQueueTest#testTemporaryTrue()

Project: activemq-artemis
File: SessionCreateAndDeleteQueueTest.java
@Test
public void testTemporaryTrue() throws Exception {
    ClientSession session = createSessionFactory(locator).createSession(false, true, true);
    session.createTemporaryQueue(address, queueName);
    Binding binding = server.getPostOffice().getBinding(queueName);
    Queue q = (Queue) binding.getBindable();
    Assert.assertTrue(q.isTemporary());
    session.close();
}

46. SessionCreateAndDeleteQueueTest#testTemporaryFalse()

Project: activemq-artemis
File: SessionCreateAndDeleteQueueTest.java
@Test
public void testTemporaryFalse() throws Exception {
    ClientSession session = createSessionFactory(locator).createSession(false, true, true);
    session.createQueue(address, queueName, false);
    Binding binding = server.getPostOffice().getBinding(queueName);
    Queue q = (Queue) binding.getBindable();
    Assert.assertFalse(q.isTemporary());
    session.close();
}

47. SessionCreateAndDeleteQueueTest#testDurableTrue()

Project: activemq-artemis
File: SessionCreateAndDeleteQueueTest.java
@Test
public void testDurableTrue() throws Exception {
    ClientSession session = createSessionFactory(locator).createSession(false, true, true);
    session.createQueue(address, queueName, true);
    Binding binding = server.getPostOffice().getBinding(queueName);
    Queue q = (Queue) binding.getBindable();
    Assert.assertTrue(q.isDurable());
    session.close();
}

48. SessionCreateAndDeleteQueueTest#testDurableFalse()

Project: activemq-artemis
File: SessionCreateAndDeleteQueueTest.java
@Test
public void testDurableFalse() throws Exception {
    ClientSession session = createSessionFactory(locator).createSession(false, true, true);
    session.createQueue(address, queueName, false);
    Binding binding = server.getPostOffice().getBinding(queueName);
    Queue q = (Queue) binding.getBindable();
    Assert.assertFalse(q.isDurable());
    session.close();
}

49. PagingTest#testRouteOnTopWithMultipleQueues()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testRouteOnTopWithMultipleQueues() throws Exception {
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnDurableSend(false);
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, 0);
    session.createQueue("Q", "Q1", "dest=1", true);
    session.createQueue("Q", "Q2", "dest=2", true);
    session.createQueue("Q", "Q3", "dest=3", true);
    Queue queue = server.locateQueue(new SimpleString("Q1"));
    queue.getPageSubscription().getPagingStore().startPaging();
    ClientProducer prod = session.createProducer("Q");
    ClientMessage msg = session.createMessage(true);
    msg.putIntProperty("dest", 1);
    prod.send(msg);
    session.commit();
    msg = session.createMessage(true);
    msg.putIntProperty("dest", 2);
    prod.send(msg);
    session.commit();
    session.start();
    ClientConsumer cons1 = session.createConsumer("Q1");
    msg = cons1.receive(5000);
    assertNotNull(msg);
    msg.acknowledge();
    ClientConsumer cons2 = session.createConsumer("Q2");
    msg = cons2.receive(5000);
    assertNotNull(msg);
    queue.getPageSubscription().getPagingStore().forceAnotherPage();
    msg = session.createMessage(true);
    msg.putIntProperty("dest", 1);
    prod.send(msg);
    session.commit();
    msg = cons1.receive(5000);
    assertNotNull(msg);
    msg.acknowledge();
    queue.getPageSubscription().cleanupEntries(false);
    System.out.println("Waiting there");
    server.stop();
}

50. 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();
    }
}

51. PagingTest#testRestartWithComplete()

Project: activemq-artemis
File: PagingTest.java
// The pages are complete, and this is simulating a scenario where the server crashed before deleting the pages.
@Test
public void testRestartWithComplete() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig();
    final AtomicBoolean mainCleanup = new AtomicBoolean(true);
    class InterruptedCursorProvider extends PageCursorProviderImpl {

        InterruptedCursorProvider(PagingStore pagingStore, StorageManager storageManager, Executor executor, int maxCacheSize) {
            super(pagingStore, storageManager, executor, maxCacheSize);
        }

        @Override
        public void cleanup() {
            if (mainCleanup.get()) {
                super.cleanup();
            } else {
                try {
                    pagingStore.unlock();
                } catch (Throwable ignored) {
                }
            }
        }
    }
    server = new ActiveMQServerImpl(config, ManagementFactory.getPlatformMBeanServer(), new ActiveMQSecurityManagerImpl()) {

        @Override
        protected PagingStoreFactoryNIO getPagingStoreFactory() {
            return new PagingStoreFactoryNIO(this.getStorageManager(), this.getConfiguration().getPagingLocation(), this.getConfiguration().getJournalBufferTimeout_NIO(), this.getScheduledPool(), this.getExecutorFactory(), this.getConfiguration().isJournalSyncNonTransactional(), null) {

                @Override
                public PageCursorProvider newCursorProvider(PagingStore store, StorageManager storageManager, AddressSettings addressSettings, Executor executor) {
                    return new InterruptedCursorProvider(store, storageManager, executor, addressSettings.getPageCacheMaxSize());
                }
            };
        }
    };
    addServer(server);
    AddressSettings defaultSetting = new AddressSettings().setPageSizeBytes(PagingTest.PAGE_SIZE).setMaxSizeBytes(PagingTest.PAGE_MAX).setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE);
    server.getAddressSettingsRepository().addMatch("#", defaultSetting);
    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);
    Queue queue = server.locateQueue(ADDRESS);
    queue.getPageSubscription().getPagingStore().startPaging();
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message;
    for (int i = 0; i < 20; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(new byte[100 * 4]);
        message.putIntProperty(new SimpleString("idi"), i);
        producer.send(message);
        session.commit();
        if (i < 19) {
            queue.getPageSubscription().getPagingStore().forceAnotherPage();
        }
    }
    Assert.assertEquals(20, queue.getPageSubscription().getPagingStore().getCurrentWritingPage());
    // This will force a scenario where the pages are cleaned up. When restarting we need to check if the current page is complete
    // if it is complete we must move to another page avoiding races on cleanup
    // which could happen during a crash / restart
    long tx = server.getStorageManager().generateID();
    for (int i = 1; i <= 20; i++) {
        server.getStorageManager().storePageCompleteTransactional(tx, queue.getID(), new PagePositionImpl(i, 1));
    }
    server.getStorageManager().commit(tx);
    session.close();
    sf.close();
    server.stop();
    mainCleanup.set(false);
    logger.trace("Server restart");
    server.start();
    queue = server.locateQueue(ADDRESS);
    locator = createInVMNonHALocator();
    sf = createSessionFactory(locator);
    session = sf.createSession(null, null, false, false, true, false, 0);
    producer = session.createProducer(PagingTest.ADDRESS);
    for (int i = 0; i < 10; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(new byte[100 * 4]);
        message.putIntProperty(new SimpleString("newid"), i);
        producer.send(message);
        session.commit();
        if (i == 5) {
            queue.getPageSubscription().getPagingStore().forceAnotherPage();
        }
    }
    mainCleanup.set(true);
    queue = server.locateQueue(ADDRESS);
    queue.getPageSubscription().cleanupEntries(false);
    queue.getPageSubscription().getPagingStore().getCursorProvider().cleanup();
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    session.start();
    for (int i = 0; i < 10; i++) {
        message = consumer.receive(5000);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getIntProperty("newid").intValue());
        message.acknowledge();
    }
    server.stop();
//      Thread.sleep(5000);
}

52. PagingTest#testRollbackOnSendThenSendMore()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testRollbackOnSendThenSendMore() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(null, null, false, false, true, false, 0);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    Queue queue = server.locateQueue(ADDRESS);
    queue.getPageSubscription().getPagingStore().startPaging();
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message;
    for (int i = 0; i < 20; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(new byte[100 * 4]);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
        session.commit();
        queue.getPageSubscription().getPagingStore().forceAnotherPage();
    }
    for (int i = 20; i < 24; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(new byte[100 * 4]);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
    }
    session.rollback();
    ClientSession consumerSession = sf.createSession(false, false);
    queue.getPageSubscription().getPagingStore().disableCleanup();
    queue.getPageSubscription().getPagingStore().getCursorProvider().cleanup();
    consumerSession.start();
    ClientConsumer consumer = consumerSession.createConsumer(ADDRESS, SimpleString.toSimpleString("id > 0"));
    for (int i = 0; i < 19; i++) {
        ClientMessage messageRec = consumer.receive(5000);
        System.err.println("msg::" + messageRec);
        Assert.assertNotNull(messageRec);
        messageRec.acknowledge();
        consumerSession.commit();
        // The only reason I'm calling cleanup directly is that it would be easy to debug in case of bugs
        // if you see an issue with cleanup here, enjoy debugging this method
        queue.getPageSubscription().getPagingStore().getCursorProvider().cleanup();
    }
    queue.getPageSubscription().getPagingStore().enableCleanup();
    consumerSession.close();
    session.close();
    sf.close();
    server.stop();
}

53. PagingTest#internaltestSendReceivePaging()

Project: activemq-artemis
File: PagingTest.java
private void internaltestSendReceivePaging(final boolean persistentMessages) throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfIntegers = 256;
    final int numberOfMessages = 1000;
    locator = createInVMNonHALocator().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);
    Queue queue = server.locateQueue(ADDRESS);
    queue.getPageSubscription().getPagingStore().startPaging();
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    byte[] body = new byte[numberOfIntegers * 4];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= numberOfIntegers; j++) {
        bb.putInt(j);
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(persistentMessages);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
    }
    session.close();
    sf.close();
    locator.close();
    server.stop();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    locator = createInVMNonHALocator();
    sf = createSessionFactory(locator);
    session = sf.createSession(null, null, false, true, true, false, 0);
    ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);
    session.start();
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage message2 = consumer.receive(PagingTest.RECEIVE_TIMEOUT);
        Assert.assertNotNull(message2);
        Assert.assertEquals(i, message2.getIntProperty("id").intValue());
        assertEquals(body.length, message2.getBodySize());
        message2.acknowledge();
        Assert.assertNotNull(message2);
        if (i % 1000 == 0) {
            session.commit();
        }
        try {
            assertBodiesEqual(body, message2.getBodyBuffer());
        } catch (AssertionError e) {
            PagingTest.log.info("Expected buffer:" + ActiveMQTestBase.dumpBytesHex(body, 40));
            PagingTest.log.info("Arriving buffer:" + ActiveMQTestBase.dumpBytesHex(message2.getBodyBuffer().toByteBuffer().array(), 40));
            throw e;
        }
    }
    consumer.close();
    session.close();
}

54. PagingTest#testDeletePhysicalPages()

Project: activemq-artemis
File: PagingTest.java
/**
    * This test will remove all the page directories during a restart, simulating a crash scenario. The server should still start after this
    */
@Test
public void testDeletePhysicalPages() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setPersistDeliveryCountBeforeDelivery(true);
    config.setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 1000;
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    session.close();
    session = null;
    sf.close();
    locator.close();
    server.stop();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    locator = createInVMNonHALocator();
    sf = createSessionFactory(locator);
    Queue queue = server.locateQueue(ADDRESS);
    assertEquals(numberOfMessages, getMessageCount(queue));
    int msgReceived = 0;
    ClientSession sessionConsumer = sf.createSession(false, false, false);
    sessionConsumer.start();
    ClientConsumer consumer = sessionConsumer.createConsumer(PagingTest.ADDRESS);
    for (int msgCount = 0; msgCount < numberOfMessages; msgCount++) {
        log.info("Received " + msgCount);
        msgReceived++;
        ClientMessage msg = consumer.receiveImmediate();
        if (msg == null) {
            log.info("It's null. leaving now");
            sessionConsumer.commit();
            fail("Didn't receive a message");
        }
        msg.acknowledge();
        if (msgCount % 5 == 0) {
            log.info("commit");
            sessionConsumer.commit();
        }
    }
    sessionConsumer.commit();
    sessionConsumer.close();
    sf.close();
    locator.close();
    assertEquals(0, getMessageCount(queue));
    long timeout = System.currentTimeMillis() + 5000;
    while (timeout > System.currentTimeMillis() && queue.getPageSubscription().getPagingStore().isPaging()) {
        Thread.sleep(100);
    }
    assertFalse(queue.getPageSubscription().getPagingStore().isPaging());
    server.stop();
    // Deleting the paging data. Simulating a failure
    // a dumb user, or anything that will remove the data
    deleteDirectory(new File(getPageDir()));
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    queue = server.locateQueue(ADDRESS);
    sf = createSessionFactory(locator);
    session = sf.createSession(false, false, false);
    producer = session.createProducer(PagingTest.ADDRESS);
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    server.stop();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    locator = createInVMNonHALocator();
    sf = createSessionFactory(locator);
    queue = server.locateQueue(ADDRESS);
    // assertEquals(numberOfMessages, getMessageCount(queue));
    msgReceived = 0;
    sessionConsumer = sf.createSession(false, false, false);
    sessionConsumer.start();
    consumer = sessionConsumer.createConsumer(PagingTest.ADDRESS);
    for (int msgCount = 0; msgCount < numberOfMessages; msgCount++) {
        log.info("Received " + msgCount);
        msgReceived++;
        ClientMessage msg = consumer.receiveImmediate();
        if (msg == null) {
            log.info("It's null. leaving now");
            sessionConsumer.commit();
            fail("Didn't receive a message");
        }
        msg.acknowledge();
        if (msgCount % 5 == 0) {
            log.info("commit");
            sessionConsumer.commit();
        }
    }
    sessionConsumer.commit();
    sessionConsumer.close();
}

55. PagingTest#testReceiveImmediate()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testReceiveImmediate() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 1000;
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    session.close();
    session = null;
    sf.close();
    locator.close();
    server.stop();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    locator = createInVMNonHALocator();
    sf = createSessionFactory(locator);
    Queue queue = server.locateQueue(ADDRESS);
    assertEquals(numberOfMessages, getMessageCount(queue));
    int msgReceived = 0;
    ClientSession sessionConsumer = sf.createSession(false, false, false);
    sessionConsumer.start();
    ClientConsumer consumer = sessionConsumer.createConsumer(PagingTest.ADDRESS);
    for (int msgCount = 0; msgCount < numberOfMessages; msgCount++) {
        log.info("Received " + msgCount);
        msgReceived++;
        ClientMessage msg = consumer.receiveImmediate();
        if (msg == null) {
            log.info("It's null. leaving now");
            sessionConsumer.commit();
            fail("Didn't receive a message");
        }
        msg.acknowledge();
        if (msgCount % 5 == 0) {
            log.info("commit");
            sessionConsumer.commit();
        }
    }
    sessionConsumer.commit();
    sessionConsumer.close();
    sf.close();
    locator.close();
    assertEquals(0, getMessageCount(queue));
    long timeout = System.currentTimeMillis() + 5000;
    while (timeout > System.currentTimeMillis() && queue.getPageSubscription().getPagingStore().isPaging()) {
        Thread.sleep(100);
    }
    assertFalse(queue.getPageSubscription().getPagingStore().isPaging());
}

56. PagingTest#testPreparePersistent()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testPreparePersistent() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 5000;
    final int numberOfTX = 10;
    final int messagesPerTX = numberOfMessages / numberOfTX;
    locator = createInVMNonHALocator();
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty(new SimpleString("id"), i);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    session.close();
    session = null;
    sf.close();
    locator.close();
    server.stop();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    locator = createInVMNonHALocator();
    sf = createSessionFactory(locator);
    Queue queue = server.locateQueue(ADDRESS);
    assertEquals(numberOfMessages, getMessageCount(queue));
    LinkedList<Xid> xids = new LinkedList<>();
    int msgReceived = 0;
    for (int i = 0; i < numberOfTX; i++) {
        ClientSession sessionConsumer = sf.createSession(true, false, false);
        Xid xid = newXID();
        xids.add(xid);
        sessionConsumer.start(xid, XAResource.TMNOFLAGS);
        sessionConsumer.start();
        ClientConsumer consumer = sessionConsumer.createConsumer(PagingTest.ADDRESS);
        for (int msgCount = 0; msgCount < messagesPerTX; msgCount++) {
            if (msgReceived == numberOfMessages) {
                break;
            }
            msgReceived++;
            ClientMessage msg = consumer.receive(10000);
            assertNotNull(msg);
            msg.acknowledge();
        }
        sessionConsumer.end(xid, XAResource.TMSUCCESS);
        sessionConsumer.prepare(xid);
        sessionConsumer.close();
    }
    ClientSession sessionCheck = sf.createSession(true, true);
    ClientConsumer consumer = sessionCheck.createConsumer(PagingTest.ADDRESS);
    assertNull(consumer.receiveImmediate());
    sessionCheck.close();
    assertEquals(numberOfMessages, getMessageCount(queue));
    sf.close();
    locator.close();
    server.stop();
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    waitForServerToStart(server);
    queue = server.locateQueue(ADDRESS);
    locator = createInVMNonHALocator();
    sf = createSessionFactory(locator);
    session = sf.createSession(true, false, false);
    consumer = session.createConsumer(PagingTest.ADDRESS);
    session.start();
    assertEquals(numberOfMessages, getMessageCount(queue));
    ClientMessage msg = consumer.receive(5000);
    if (msg != null) {
        while (true) {
            ClientMessage msg2 = consumer.receive(1000);
            if (msg2 == null) {
                break;
            }
        }
    }
    assertNull(msg);
    for (int i = xids.size() - 1; i >= 0; i--) {
        Xid xid = xids.get(i);
        session.rollback(xid);
    }
    xids.clear();
    session.close();
    session = sf.createSession(false, false, false);
    session.start();
    consumer = session.createConsumer(PagingTest.ADDRESS);
    for (int i = 0; i < numberOfMessages; i++) {
        msg = consumer.receive(1000);
        assertNotNull(msg);
        msg.acknowledge();
        assertEquals(i, msg.getIntProperty("id").intValue());
        if (i % 500 == 0) {
            session.commit();
        }
    }
    session.commit();
    session.close();
    sf.close();
    locator.close();
    assertEquals(0, getMessageCount(queue));
    waitForNotPaging(queue);
}

57. PagingTest#testDeleteQueueRestart()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testDeleteQueueRestart() throws Exception {
    clearDataRecreateServerDirs();
    // disable compact
    Configuration config = createDefaultInVMConfig().setJournalDirectory(getJournalDir()).setJournalSyncNonTransactional(false).setJournalCompactMinFiles(0);
    ActiveMQServer server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 5000;
    locator = createInVMNonHALocator().setConsumerWindowSize(10 * 1024 * 1024).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    SimpleString QUEUE2 = ADDRESS.concat("-2");
    ClientSessionFactory sf = locator.createSessionFactory();
    ClientSession session = sf.createSession(false, false, false);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    session.createQueue(PagingTest.ADDRESS, QUEUE2, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    // This is just to hold some messages as being delivered
    ClientConsumerInternal cons = (ClientConsumerInternal) session.createConsumer(ADDRESS);
    ClientConsumerInternal cons2 = (ClientConsumerInternal) session.createConsumer(QUEUE2);
    ClientMessage message = null;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    producer.close();
    session.start();
    long timeout = System.currentTimeMillis() + 30000;
    // I want the buffer full to make sure there are pending messages on the server's side
    while (System.currentTimeMillis() < timeout && (cons.getBufferSize() < 1000 || cons2.getBufferSize() < 1000)) {
        System.out.println("cons1 buffer = " + cons.getBufferSize() + ", cons2 buffer = " + cons2.getBufferSize());
        Thread.sleep(100);
    }
    assertTrue(cons.getBufferSize() >= 1000);
    assertTrue(cons2.getBufferSize() >= 1000);
    session.close();
    Queue queue = server.locateQueue(QUEUE2);
    long deletedQueueID = queue.getID();
    server.destroyQueue(QUEUE2);
    sf.close();
    locator.close();
    locator = null;
    sf = null;
    server.stop();
    final HashMap<Integer, AtomicInteger> recordsType = countJournal(config);
    for (Map.Entry<Integer, AtomicInteger> entry : recordsType.entrySet()) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
    assertNull("The system is acking page records instead of just delete data", recordsType.get(new Integer(JournalRecordIds.ACKNOWLEDGE_CURSOR)));
    Pair<List<RecordInfo>, List<PreparedTransactionInfo>> journalData = loadMessageJournal(config);
    HashSet<Long> deletedQueueReferences = new HashSet<>();
    for (RecordInfo info : journalData.getA()) {
        if (info.getUserRecordType() == JournalRecordIds.ADD_REF) {
            DescribeJournal.ReferenceDescribe ref = (ReferenceDescribe) DescribeJournal.newObjectEncoding(info);
            if (ref.refEncoding.queueID == deletedQueueID) {
                deletedQueueReferences.add(new Long(info.id));
            }
        } else if (info.getUserRecordType() == JournalRecordIds.ACKNOWLEDGE_REF) {
            AckDescribe ref = (AckDescribe) DescribeJournal.newObjectEncoding(info);
            if (ref.refEncoding.queueID == deletedQueueID) {
                deletedQueueReferences.remove(new Long(info.id));
            }
        }
    }
    if (!deletedQueueReferences.isEmpty()) {
        for (Long value : deletedQueueReferences) {
            System.out.println("Deleted Queue still has a reference:" + value);
        }
        fail("Deleted queue still have references");
    }
    server.start();
    locator = createInVMNonHALocator();
    locator.setConsumerWindowSize(10 * 1024 * 1024);
    sf = locator.createSessionFactory();
    session = sf.createSession(false, false, false);
    cons = (ClientConsumerInternal) session.createConsumer(ADDRESS);
    session.start();
    for (int i = 0; i < numberOfMessages; i++) {
        message = cons.receive(5000);
        assertNotNull(message);
        message.acknowledge();
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    producer.close();
    session.close();
    queue = server.locateQueue(PagingTest.ADDRESS);
    assertEquals(0, getMessageCount(queue));
    timeout = System.currentTimeMillis() + 10000;
    while (timeout > System.currentTimeMillis() && queue.getPageSubscription().getPagingStore().isPaging()) {
        Thread.sleep(100);
    }
    assertFalse(queue.getPageSubscription().getPagingStore().isPaging());
    server.stop();
}

58. PagingTest#testPreparedACKAndRestart()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testPreparedACKAndRestart() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 50;
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true).setAckBatchSize(0);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    Queue queue = server.locateQueue(PagingTest.ADDRESS);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    queue.getPageSubscription().getPagingStore().startPaging();
    forcePage(queue);
    // Send many messages, 5 on each page
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage message = session.createMessage(true);
        message.putIntProperty("count", i);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        producer.send(message);
        if ((i + 1) % 5 == 0) {
            System.out.println("Forcing at " + i);
            session.commit();
            queue.getPageSubscription().getPagingStore().forceAnotherPage();
        }
    }
    session.close();
    session = sf.createSession(true, false, false);
    Xid xidConsumeNoCommit = newXID();
    session.start(xidConsumeNoCommit, XAResource.TMNOFLAGS);
    ClientConsumer cons = session.createConsumer(ADDRESS);
    session.start();
    // First message is consumed, prepared, will be rolled back later
    ClientMessage firstMessageConsumed = cons.receive(5000);
    assertNotNull(firstMessageConsumed);
    firstMessageConsumed.acknowledge();
    session.end(xidConsumeNoCommit, XAResource.TMSUCCESS);
    session.prepare(xidConsumeNoCommit);
    Xid xidConsumeCommit = newXID();
    session.start(xidConsumeCommit, XAResource.TMNOFLAGS);
    Xid neverCommittedXID = newXID();
    for (int i = 1; i < numberOfMessages; i++) {
        if (i == 20) {
            // I elected a single message to be in prepared state, it won't ever be committed
            session.end(xidConsumeCommit, XAResource.TMSUCCESS);
            session.commit(xidConsumeCommit, true);
            session.start(neverCommittedXID, XAResource.TMNOFLAGS);
        }
        ClientMessage message = cons.receive(5000);
        assertNotNull(message);
        System.out.println("ACK " + i);
        message.acknowledge();
        assertEquals(i, message.getIntProperty("count").intValue());
        if (i == 20) {
            session.end(neverCommittedXID, XAResource.TMSUCCESS);
            session.prepare(neverCommittedXID);
            xidConsumeCommit = newXID();
            session.start(xidConsumeCommit, XAResource.TMNOFLAGS);
        }
    }
    session.end(xidConsumeCommit, XAResource.TMSUCCESS);
    session.commit(xidConsumeCommit, true);
    session.close();
    sf.close();
    // Restart the server, and we expect cleanup to not destroy any page with prepared data
    server.stop();
    server.start();
    sf = createSessionFactory(locator);
    session = sf.createSession(false, true, true);
    queue = server.locateQueue(ADDRESS);
    assertTrue(queue.getPageSubscription().getPagingStore().isPaging());
    producer = session.createProducer(ADDRESS);
    for (int i = numberOfMessages; i < numberOfMessages * 2; i++) {
        ClientMessage message = session.createMessage(true);
        message.putIntProperty("count", i);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        producer.send(message);
        if ((i + 1) % 5 == 0) {
            session.commit();
            queue.getPageSubscription().getPagingStore().forceAnotherPage();
        }
    }
    cons = session.createConsumer(ADDRESS);
    session.start();
    for (int i = numberOfMessages; i < numberOfMessages * 2; i++) {
        ClientMessage message = cons.receive(5000);
        assertNotNull(message);
        assertEquals(i, message.getIntProperty("count").intValue());
        message.acknowledge();
    }
    assertNull(cons.receiveImmediate());
    session.commit();
    System.out.println("count = " + getMessageCount(queue));
    session.commit();
    session.close();
    session = sf.createSession(true, false, false);
    session.rollback(xidConsumeNoCommit);
    session.start();
    xidConsumeCommit = newXID();
    session.start(xidConsumeCommit, XAResource.TMNOFLAGS);
    cons = session.createConsumer(ADDRESS);
    session.start();
    ClientMessage message = cons.receive(5000);
    assertNotNull(message);
    message.acknowledge();
    session.end(xidConsumeCommit, XAResource.TMSUCCESS);
    session.commit(xidConsumeCommit, true);
    session.close();
}

59. PagingTest#testFirstPageCompleteNotDeleted()

Project: activemq-artemis
File: PagingTest.java
// First page is complete but it wasn't deleted
@Test
public void testFirstPageCompleteNotDeleted() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 20;
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    Queue queue = server.createQueue(ADDRESS, ADDRESS, null, true, false);
    queue.getPageSubscription().getPagingStore().startPaging();
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        message.putIntProperty("count", i);
        producer.send(message);
        if ((i + 1) % 5 == 0) {
            session.commit();
            queue.getPageSubscription().getPagingStore().forceAnotherPage();
        }
    }
    session.commit();
    producer.close();
    session.close();
    // This will make the cursor to set the page complete and not actually delete it
    queue.getPageSubscription().getPagingStore().disableCleanup();
    session = sf.createSession(false, false, false);
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    session.start();
    for (int i = 0; i < 5; i++) {
        ClientMessage msg = consumer.receive(2000);
        assertNotNull(msg);
        assertEquals(i, msg.getIntProperty("count").intValue());
        msg.individualAcknowledge();
        System.out.println(msg);
    }
    session.commit();
    session.close();
    server.stop();
    server.start();
    sf = createSessionFactory(locator);
    session = sf.createSession(false, false, false);
    consumer = session.createConsumer(ADDRESS);
    session.start();
    for (int i = 5; i < numberOfMessages; i++) {
        ClientMessage msg = consumer.receive(2000);
        assertNotNull(msg);
        assertEquals(i, msg.getIntProperty("count").intValue());
        msg.acknowledge();
        System.out.println(msg);
    }
    assertNull(consumer.receiveImmediate());
    session.commit();
    session.close();
    sf.close();
    locator.close();
}

60. PagingTest#testPageCleanup()

Project: activemq-artemis
File: PagingTest.java
@Test
public void testPageCleanup() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false);
    server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, new HashMap<String, AddressSettings>());
    server.start();
    final int numberOfMessages = 5000;
    locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(PagingTest.ADDRESS);
    ClientMessage message = null;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    producer.close();
    session.close();
    session = sf.createSession(false, false, false);
    producer = session.createProducer(PagingTest.ADDRESS);
    producer.send(session.createMessage(true));
    session.rollback();
    producer.close();
    session.close();
    session = sf.createSession(false, false, false);
    producer = session.createProducer(PagingTest.ADDRESS);
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    producer.close();
    session.close();
    //System.out.println("Just sent " + numberOfMessages + " messages.");
    Queue queue = server.locateQueue(PagingTest.ADDRESS);
    session = sf.createSession(false, false, false);
    session.start();
    assertEquals(numberOfMessages * 2, getMessageCount(queue));
    // The consumer has to be created after the getMessageCount(queue) assertion
    // otherwise delivery could alter the messagecount and give us a false failure
    ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);
    ClientMessage msg = null;
    for (int i = 0; i < numberOfMessages * 2; i++) {
        msg = consumer.receive(1000);
        assertNotNull(msg);
        msg.acknowledge();
        if (i % 500 == 0) {
            session.commit();
        }
    }
    session.commit();
    consumer.close();
    session.close();
    sf.close();
    locator.close();
    assertEquals(0, getMessageCount(queue));
    waitForNotPaging(queue);
    server.stop();
    HashMap<Integer, AtomicInteger> counts = countJournalLivingRecords(server.getConfiguration());
    AtomicInteger pgComplete = counts.get(JournalRecordIds.PAGE_CURSOR_COMPLETE);
    assertTrue(pgComplete == null || pgComplete.get() == 0);
    System.out.println("pgComplete = " + pgComplete);
}

61. ExpireTestOnRestartTest#testRestartWithExpire()

Project: activemq-artemis
File: ExpireTestOnRestartTest.java
// The biggest problem on this test was the exceptions that happened. I couldn't find any wrong state beyond the exceptions
@Test
public void testRestartWithExpire() throws Exception {
    int NUMBER_OF_EXPIRED_MESSAGES = 1000;
    ServerLocator locator = createInVMNonHALocator();
    locator.setBlockOnDurableSend(false);
    ClientSessionFactory factory = locator.createSessionFactory();
    ClientSession session = factory.createSession(true, true);
    session.createQueue("test", "test", true);
    session.createQueue("exp", "exp", true);
    ClientProducer prod = session.createProducer("test");
    for (int i = 0; i < 10; i++) {
        ClientMessage message = session.createMessage(true);
        message.getBodyBuffer().writeBytes(new byte[1024 * 10]);
        prod.send(message);
    }
    for (int i = 0; i < NUMBER_OF_EXPIRED_MESSAGES; i++) {
        ClientMessage message = session.createMessage(true);
        message.putIntProperty("i", i);
        message.getBodyBuffer().writeBytes(new byte[1024 * 10]);
        message.setExpiration(System.currentTimeMillis() + 5000);
        prod.send(message);
    }
    session.commit();
    session.close();
    server.stop();
    server.getConfiguration().setMessageExpiryScanPeriod(1);
    // enough time for expiration of the messages
    Thread.sleep(5500);
    server.start();
    Queue queue = server.locateQueue(SimpleString.toSimpleString("test"));
    factory = locator.createSessionFactory();
    session = factory.createSession(false, false);
    ClientConsumer cons = session.createConsumer("test");
    session.start();
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = cons.receive(5000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    assertNull(cons.receiveImmediate());
    cons.close();
    long timeout = System.currentTimeMillis() + 60000;
    while (queue.getPageSubscription().getPagingStore().isPaging() && timeout > System.currentTimeMillis()) {
        Thread.sleep(1);
    }
    assertFalse(queue.getPageSubscription().getPagingStore().isPaging());
    cons = session.createConsumer("exp");
    for (int i = 0; i < NUMBER_OF_EXPIRED_MESSAGES; i++) {
        ClientMessage msg = cons.receive(5000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    session.commit();
    int extras = 0;
    ClientMessage msg;
    while ((msg = cons.receiveImmediate()) != null) {
        System.out.println(msg);
        extras++;
    }
    assertEquals("Received extra messages on expire address", 0, extras);
    session.commit();
    session.close();
    locator.close();
}

62. ConcurrentCreateDeleteProduceTest#testConcurrentProduceCreateAndDelete()

Project: activemq-artemis
File: ConcurrentCreateDeleteProduceTest.java
@Test
public void testConcurrentProduceCreateAndDelete() throws Throwable {
    ClientSessionFactory factory = locator.createSessionFactory();
    ClientSession session = factory.createSession(true, true);
    ClientProducer producer = session.createProducer(ADDRESS);
    // just to make it page forever
    Queue serverQueue = server.createQueue(ADDRESS, SimpleString.toSimpleString("everPage"), null, true, false);
    serverQueue.getPageSubscription().getPagingStore().startPaging();
    Consumer[] consumers = new Consumer[10];
    for (int i = 0; i < consumers.length; i++) {
        consumers[i] = new Consumer();
        consumers[i].start();
    }
    for (int i = 0; i < 50000 && running; i++) {
        producer.send(session.createMessage(true));
    //Thread.sleep(10);
    }
    session.close();
    running = false;
    for (Consumer consumer : consumers) {
        consumer.join();
        if (consumer.ex != null) {
            throw consumer.ex;
        }
    }
}

63. CommitRollbackTest#testAsyncConsumerRollback()

Project: activemq-artemis
File: CommitRollbackTest.java
@Test
public void testAsyncConsumerRollback() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setAckBatchSize(0);
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    final ClientSession session = cf.createSession(false, true, false);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    CountDownLatch latch = new CountDownLatch(numMessages);
    session.start();
    cc.setMessageHandler(new ackHandler(session, latch));
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    Assert.assertEquals(numMessages, getMessageCount(q));
    session.stop();
    session.rollback();
    Assert.assertEquals(0, q.getDeliveringCount());
    Assert.assertEquals(numMessages, getMessageCount(q));
    latch = new CountDownLatch(numMessages);
    cc.setMessageHandler(new ackHandler(session, latch));
    session.start();
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    sendSession.close();
    session.close();
    cf.close();
}

64. CommitRollbackTest#testAsyncConsumerCommit()

Project: activemq-artemis
File: CommitRollbackTest.java
@Test
public void testAsyncConsumerCommit() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setAckBatchSize(0);
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    final ClientSession session = cf.createSession(false, true, false);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    final CountDownLatch latch = new CountDownLatch(numMessages);
    session.start();
    cc.setMessageHandler(new MessageHandler() {

        @Override
        public void onMessage(final ClientMessage message) {
            try {
                message.acknowledge();
            } catch (ActiveMQException e) {
                try {
                    session.close();
                } catch (ActiveMQException e1) {
                    e1.printStackTrace();
                }
            }
            latch.countDown();
        }
    });
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    Assert.assertEquals(numMessages, getMessageCount(q));
    session.commit();
    Assert.assertEquals(0, q.getDeliveringCount());
    Assert.assertEquals(0, getMessageCount(q));
    sendSession.close();
    session.close();
}

65. CommitRollbackTest#testReceiveWithRollback()

Project: activemq-artemis
File: CommitRollbackTest.java
@Test
public void testReceiveWithRollback() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientSession session = cf.createSession(false, false, false);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = cc.receive(5000);
        Assert.assertNotNull(cm);
        cm.acknowledge();
    }
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    session.rollback();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = cc.receive(5000);
        Assert.assertNotNull(cm);
        cm.acknowledge();
    }
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    session.close();
    sendSession.close();
}

66. CommitRollbackTest#testReceiveWithCommit()

Project: activemq-artemis
File: CommitRollbackTest.java
@Test
public void testReceiveWithCommit() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientSession session = cf.createSession(false, false, false);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = cc.receive(5000);
        Assert.assertNotNull(cm);
        cm.acknowledge();
    }
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    session.commit();
    Assert.assertEquals(0, q.getDeliveringCount());
    session.close();
    sendSession.close();
}

67. AutoDeleteJmsDestinationTest#testAutoDeleteNegative()

Project: activemq-artemis
File: AutoDeleteJmsDestinationTest.java
@Test
public void testAutoDeleteNegative() throws Exception {
    server.getAddressSettingsRepository().addMatch("#", new AddressSettings().setAutoDeleteJmsQueues(false));
    Connection connection = cf.createConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    javax.jms.Queue queue = ActiveMQJMSClient.createQueue("test");
    MessageProducer producer = session.createProducer(queue);
    final int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        TextMessage mess = session.createTextMessage("msg" + i);
        producer.send(mess);
    }
    producer.close();
    MessageConsumer messageConsumer = session.createConsumer(queue);
    connection.start();
    for (int i = 0; i < numMessages - 1; i++) {
        Message m = messageConsumer.receive(5000);
        Assert.assertNotNull(m);
    }
    session.close();
    // ensure the queue is still there
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString("jms.queue.test")).getBindable();
    Assert.assertEquals(1, q.getMessageCount());
    Assert.assertEquals(numMessages, q.getMessagesAdded());
    session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    messageConsumer = session.createConsumer(queue);
    Message m = messageConsumer.receive(5000);
    Assert.assertNotNull(m);
    connection.close();
    // ensure the queue was not removed
    Assert.assertNotNull(server.getPostOffice().getBinding(new SimpleString("jms.queue.test")));
}

68. AutoDeleteJmsDestinationTest#testAutoDeleteQueue()

Project: activemq-artemis
File: AutoDeleteJmsDestinationTest.java
@Test
public void testAutoDeleteQueue() throws Exception {
    Connection connection = cf.createConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    javax.jms.Queue queue = ActiveMQJMSClient.createQueue("test");
    MessageProducer producer = session.createProducer(queue);
    final int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        TextMessage mess = session.createTextMessage("msg" + i);
        producer.send(mess);
    }
    producer.close();
    MessageConsumer messageConsumer = session.createConsumer(queue);
    connection.start();
    for (int i = 0; i < numMessages - 1; i++) {
        Message m = messageConsumer.receive(5000);
        Assert.assertNotNull(m);
    }
    session.close();
    // ensure the queue is still there
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString("jms.queue.test")).getBindable();
    Assert.assertEquals(1, q.getMessageCount());
    Assert.assertEquals(numMessages, q.getMessagesAdded());
    session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    messageConsumer = session.createConsumer(queue);
    Message m = messageConsumer.receive(5000);
    Assert.assertNotNull(m);
    connection.close();
    // ensure the queue was removed
    Assert.assertNull(server.getPostOffice().getBinding(new SimpleString("jms.queue.test")));
    // make sure the JMX control was removed for the JMS queue
    assertNull(server.getManagementService().getResource("jms.queue.test"));
}

69. AcknowledgeTest#testAsyncConsumerAckLastMessageOnly()

Project: activemq-artemis
File: AcknowledgeTest.java
@Test
public void testAsyncConsumerAckLastMessageOnly() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setAckBatchSize(0);
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    final ClientSession session = cf.createSession(false, true, true);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    final CountDownLatch latch = new CountDownLatch(numMessages);
    session.start();
    cc.setMessageHandler(new MessageHandler() {

        @Override
        public void onMessage(final ClientMessage message) {
            if (latch.getCount() == 1) {
                try {
                    message.acknowledge();
                } catch (ActiveMQException e) {
                    try {
                        session.close();
                    } catch (ActiveMQException e1) {
                        e1.printStackTrace();
                    }
                }
            }
            latch.countDown();
        }
    });
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(0, q.getDeliveringCount());
    sendSession.close();
    session.close();
}

70. AcknowledgeTest#testAsyncConsumerAck()

Project: activemq-artemis
File: AcknowledgeTest.java
@Test
public void testAsyncConsumerAck() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setAckBatchSize(0);
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    final ClientSession session = cf.createSession(false, true, true);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    final CountDownLatch latch = new CountDownLatch(numMessages);
    session.start();
    cc.setMessageHandler(new MessageHandler() {

        @Override
        public void onMessage(final ClientMessage message) {
            try {
                message.acknowledge();
            } catch (ActiveMQException e) {
                try {
                    session.close();
                } catch (ActiveMQException e1) {
                    e1.printStackTrace();
                }
            }
            latch.countDown();
        }
    });
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(0, q.getDeliveringCount());
    sendSession.close();
    session.close();
}

71. AcknowledgeTest#testAsyncConsumerNoAck()

Project: activemq-artemis
File: AcknowledgeTest.java
@Test
public void testAsyncConsumerNoAck() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientSession session = cf.createSession(false, true, true);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 3;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    Thread.sleep(500);
    log.info("woke up");
    final CountDownLatch latch = new CountDownLatch(numMessages);
    session.start();
    cc.setMessageHandler(new MessageHandler() {

        int c = 0;

        @Override
        public void onMessage(final ClientMessage message) {
            log.info("Got message " + c++);
            latch.countDown();
        }
    });
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    sendSession.close();
    session.close();
}

72. AcknowledgeTest#testReceiveAckLastMessageOnly()

Project: activemq-artemis
File: AcknowledgeTest.java
@Test
public void testReceiveAckLastMessageOnly() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setAckBatchSize(0).setBlockOnAcknowledge(true);
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientSession session = cf.createSession(false, true, true);
    sendSession.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientConsumer cc = session.createConsumer(queueA);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    session.start();
    ClientMessage cm = null;
    for (int i = 0; i < numMessages; i++) {
        cm = cc.receive(5000);
        Assert.assertNotNull(cm);
    }
    cm.acknowledge();
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(0, q.getDeliveringCount());
    session.close();
    sendSession.close();
}

73. AckBatchSizeTest#testAckBatchSizeZero()

Project: activemq-artemis
File: AckBatchSizeTest.java
/*
   * tests that when the ackBatchSize is 0 we ack every message directly
   * */
@Test
public void testAckBatchSizeZero() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator().setAckBatchSize(0).setBlockOnAcknowledge(true);
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    int numMessages = 100;
    ClientSession session = cf.createSession(false, true, true);
    session.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    ClientConsumer consumer = session.createConsumer(queueA);
    session.start();
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    ClientMessage[] messages = new ClientMessage[numMessages];
    for (int i = 0; i < numMessages; i++) {
        messages[i] = consumer.receive(5000);
        Assert.assertNotNull(messages[i]);
    }
    for (int i = 0; i < numMessages; i++) {
        messages[i].acknowledge();
        Assert.assertEquals(numMessages - i - 1, q.getDeliveringCount());
    }
    sendSession.close();
    session.close();
}

74. AckBatchSizeTest#testAckBatchSize()

Project: activemq-artemis
File: AckBatchSizeTest.java
@Test
public void testAckBatchSize() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    int numMessages = 100;
    ServerLocator locator = createInVMNonHALocator().setAckBatchSize(numMessages * getMessageEncodeSize(addressA)).setBlockOnAcknowledge(true);
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientSession session = cf.createSession(false, true, true);
    session.createQueue(addressA, queueA, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
    }
    ClientConsumer consumer = session.createConsumer(queueA);
    session.start();
    for (int i = 0; i < numMessages - 1; i++) {
        ClientMessage m = consumer.receive(5000);
        m.acknowledge();
    }
    ClientMessage m = consumer.receive(5000);
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Assert.assertEquals(100, q.getDeliveringCount());
    m.acknowledge();
    Assert.assertEquals(0, q.getDeliveringCount());
    sendSession.close();
    session.close();
}

75. PagingOMETest#testPageCleanup()

Project: activemq-artemis
File: PagingOMETest.java
@Test
@BMRules(rules = { @BMRule(name = "fakeOME", targetClass = "org.apache.activemq.artemis.core.paging.cursor.PagedReferenceImpl", targetMethod = "getPagedMessage", targetLocation = "ENTRY", action = "org.apache.activemq.artemis.tests.extras.byteman.PagingOMETest.refCheck()") })
public void testPageCleanup() throws Exception {
    clearDataRecreateServerDirs();
    Configuration config = createDefaultConfig(false);
    config.setJournalSyncNonTransactional(false);
    HashMap<String, AddressSettings> map = new HashMap<>();
    AddressSettings value = new AddressSettings();
    map.put(ADDRESS.toString(), value);
    server = createServer(true, config, PAGE_SIZE, PAGE_MAX, map);
    server.start();
    final int numberOfMessages = 2;
    locator = createInVMNonHALocator();
    locator.setBlockOnNonDurableSend(true);
    locator.setBlockOnDurableSend(true);
    locator.setBlockOnAcknowledge(false);
    locator.setConsumerWindowSize(0);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, false, false);
    session.createQueue(ADDRESS, ADDRESS, null, true);
    Queue queue = server.locateQueue(ADDRESS);
    queue.getPageSubscription().getPagingStore().startPaging();
    Assert.assertTrue(queue.getPageSubscription().getPagingStore().isPaging());
    ClientProducer producer = session.createProducer(PagingOMETest.ADDRESS);
    ClientMessage message = null;
    byte[] body = new byte[MESSAGE_SIZE];
    ByteBuffer bb = ByteBuffer.wrap(body);
    for (int j = 1; j <= MESSAGE_SIZE; j++) {
        bb.put(getSamplebyte(j));
    }
    for (int i = 0; i < numberOfMessages; i++) {
        message = session.createMessage(true);
        ActiveMQBuffer bodyLocal = message.getBodyBuffer();
        bodyLocal.writeBytes(body);
        producer.send(message);
        if (i % 1000 == 0) {
            session.commit();
        }
    }
    session.commit();
    session = sf.createSession(false, false, false);
    session.start();
    assertEquals(numberOfMessages, queue.getMessageCount());
    // The consumer has to be created after the queue.getMessageCount assertion
    // otherwise delivery could alter the messagecount and give us a false failure
    ClientConsumer consumer = session.createConsumer(PagingOMETest.ADDRESS);
    ClientMessage msg = null;
    msg = consumer.receive(1000);
    failureActive = true;
    msg.individualAcknowledge();
    try {
        session.commit();
        Assert.fail("exception expected");
    } catch (Exception expected) {
    }
    failureActive = false;
    session.rollback();
    session.close();
    sf.close();
    locator.close();
    server.stop();
    server.start();
    locator = createInVMNonHALocator();
    locator.setBlockOnNonDurableSend(true);
    locator.setBlockOnDurableSend(true);
    locator.setBlockOnAcknowledge(false);
    locator.setConsumerWindowSize(0);
    sf = createSessionFactory(locator);
    session = sf.createSession(false, false, false);
    consumer = session.createConsumer(PagingOMETest.ADDRESS);
    session.start();
    for (int i = 0; i < numberOfMessages; i++) {
        msg = consumer.receive(1000);
        Assert.assertNotNull(msg);
        msg.individualAcknowledge();
    }
    Assert.assertNull(consumer.receiveImmediate());
    session.commit();
    session.close();
    sf.close();
    server.stop();
}

76. BMFailoverTest#testFailoverOnReceiveCommit()

Project: activemq-artemis
File: BMFailoverTest.java
@Test
@BMRules(rules = { @BMRule(name = "trace clientsessionimpl commit", targetClass = "org.apache.activemq.artemis.core.client.impl.ClientSessionImpl", targetMethod = "commit", targetLocation = "ENTRY", action = "org.apache.activemq.artemis.tests.extras.byteman.BMFailoverTest.serverToStop.getServer().stop(true)") })
public void testFailoverOnReceiveCommit() throws Exception {
    serverToStop = liveServer;
    locator = getServerLocator().setFailoverOnInitialConnection(true);
    createSessionFactory();
    ClientSession session = createSessionAndQueue();
    ClientSession sendSession = createSession(sf, true, true);
    ClientProducer producer = addClientProducer(sendSession.createProducer(FailoverTestBase.ADDRESS));
    sendMessages(sendSession, producer, 10);
    ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
    session.start();
    for (int i = 0; i < 10; i++) {
        ClientMessage m = consumer.receive(500);
        assertNotNull(m);
        m.acknowledge();
    }
    try {
        session.commit();
        fail("should have thrown an exception");
    } catch (ActiveMQTransactionOutcomeUnknownException e) {
    } catch (ActiveMQTransactionRolledBackException e1) {
    }
    Queue bindable = (Queue) backupServer.getServer().getPostOffice().getBinding(FailoverTestBase.ADDRESS).getBindable();
    assertEquals(10, getMessageCount(bindable));
}

77. BMFailoverTest#testFailoverOnCommit()

Project: activemq-artemis
File: BMFailoverTest.java
@Test
@BMRules(rules = { @BMRule(name = "trace clientsessionimpl commit", targetClass = "org.apache.activemq.artemis.core.client.impl.ClientSessionImpl", targetMethod = "commit", targetLocation = "ENTRY", action = "org.apache.activemq.artemis.tests.extras.byteman.BMFailoverTest.serverToStop.getServer().stop(true)") })
public void testFailoverOnCommit() throws Exception {
    serverToStop = liveServer;
    locator = getServerLocator().setFailoverOnInitialConnection(true);
    createSessionFactory();
    ClientSession session = createSessionAndQueue();
    ClientProducer producer = addClientProducer(session.createProducer(FailoverTestBase.ADDRESS));
    sendMessages(session, producer, 10);
    try {
        session.commit();
        fail("should have thrown an exception");
    } catch (ActiveMQTransactionOutcomeUnknownException e) {
    }
    sendMessages(session, producer, 10);
    session.commit();
    Queue bindable = (Queue) backupServer.getServer().getPostOffice().getBinding(FailoverTestBase.ADDRESS).getBindable();
    assertEquals(10, getMessageCount(bindable));
}

78. BMFailoverTest#testFailoverOnCommit2()

Project: activemq-artemis
File: BMFailoverTest.java
@Test
@BMRules(rules = { @BMRule(name = "trace clientsessionimpl commit", targetClass = "org.apache.activemq.artemis.core.client.impl.ClientSessionImpl", targetMethod = "start(javax.transaction.xa.Xid, int)", targetLocation = "AT EXIT", action = "org.apache.activemq.artemis.tests.extras.byteman.BMFailoverTest.serverToStop.getServer().stop(true)") })
public void testFailoverOnCommit2() throws Exception {
    serverToStop = liveServer;
    locator = getServerLocator().setFailoverOnInitialConnection(true);
    SimpleString inQueue = new SimpleString("inQueue");
    SimpleString outQueue = new SimpleString("outQueue");
    createSessionFactory();
    createSessionFactory2();
    // closeable will take care of closing it
    try (ClientSession session = sf.createSession(false, true, true);
        ClientProducer sendInitialProducer = session.createProducer()) {
        session.createQueue(inQueue, inQueue, null, true);
        session.createQueue(outQueue, outQueue, null, true);
        sendInitialProducer.send(inQueue, createMessage(session, 0, true));
    }
    ClientSession xaSessionRec = addClientSession(sf.createSession(true, false, false));
    ClientConsumer consumer = addClientConsumer(xaSessionRec.createConsumer(inQueue));
    byte[] globalTransactionId = UUIDGenerator.getInstance().generateStringUUID().getBytes();
    Xid xidRec = new XidImpl("xa2".getBytes(), 1, globalTransactionId);
    xaSessionRec.start();
    xaSessionRec.getXAResource().start(xidRec, XAResource.TMNOFLAGS);
    //failover is now occurring, receive, ack and end will be called whilst this is happening.
    ClientMessageImpl m = (ClientMessageImpl) consumer.receive(5000);
    assertNotNull(m);
    System.out.println("********************" + m.getIntProperty("counter"));
    //the mdb would ack the message before calling onMessage()
    m.acknowledge();
    try {
        //this may fail but thats ok, it depends on the race and when failover actually happens
        xaSessionRec.end(xidRec, XAResource.TMSUCCESS);
    } catch (XAException ignore) {
    }
    //we always reset the client on the RA
    ((ClientSessionInternal) xaSessionRec).resetIfNeeded();
    // closeable will take care of closing it
    try (ClientSession session = sf.createSession(false, true, true);
        ClientProducer sendInitialProducer = session.createProducer()) {
        sendInitialProducer.send(inQueue, createMessage(session, 0, true));
    }
    //now receive and send a message successfully
    globalTransactionId = UUIDGenerator.getInstance().generateStringUUID().getBytes();
    xidRec = new XidImpl("xa4".getBytes(), 1, globalTransactionId);
    xaSessionRec.getXAResource().start(xidRec, XAResource.TMNOFLAGS);
    Binding binding = backupServer.getServer().getPostOffice().getBinding(inQueue);
    Queue inQ = (Queue) binding.getBindable();
    m = (ClientMessageImpl) consumer.receive(5000);
    assertNotNull(m);
    //the mdb would ack the message before calling onMessage()
    m.acknowledge();
    System.out.println("********************" + m.getIntProperty("counter"));
    xaSessionRec.getXAResource().end(xidRec, XAResource.TMSUCCESS);
    xaSessionRec.getXAResource().prepare(xidRec);
    xaSessionRec.getXAResource().commit(xidRec, false);
    //let's close the consumer so anything pending is handled
    consumer.close();
    assertEquals(1, getMessageCount(inQ));
}

79. ServerSessionImpl#createQueue()

Project: activemq-artemis
File: ServerSessionImpl.java
@Override
public Queue createQueue(final SimpleString address, final SimpleString name, final SimpleString filterString, final boolean temporary, final boolean durable) throws Exception {
    if (durable) {
        // make sure the user has privileges to create this queue
        securityCheck(address, CheckType.CREATE_DURABLE_QUEUE, this);
    } else {
        securityCheck(address, CheckType.CREATE_NON_DURABLE_QUEUE, this);
    }
    server.checkQueueCreationLimit(getUsername());
    Queue queue;
    // any non-temporary JMS destination created via this method should be marked as auto-created
    if (!temporary && ((address.toString().startsWith(ResourceNames.JMS_QUEUE) && address.equals(name)) || address.toString().startsWith(ResourceNames.JMS_TOPIC))) {
        queue = server.createQueue(address, name, filterString, SimpleString.toSimpleString(getUsername()), durable, temporary, true);
    } else {
        queue = server.createQueue(address, name, filterString, SimpleString.toSimpleString(getUsername()), durable, temporary);
    }
    if (temporary) {
        // Temporary queue in core simply means the queue will be deleted if
        // the remoting connection
        // dies. It does not mean it will get deleted automatically when the
        // session is closed.
        // It is up to the user to delete the queue when finished with it
        TempQueueCleanerUpper cleaner = new TempQueueCleanerUpper(server, name);
        remotingConnection.addCloseListener(cleaner);
        remotingConnection.addFailureListener(cleaner);
        tempQueueCleannerUppers.put(name, cleaner);
    }
    if (logger.isDebugEnabled()) {
        logger.debug("Queue " + name + " created on address " + address + " with filter=" + filterString + " temporary = " + temporary + " durable=" + durable + " on session user=" + this.username + ", connection=" + this.remotingConnection);
    }
    return queue;
}

80. ScaleDownHandler#scaleDownSNF()

Project: activemq-artemis
File: ScaleDownHandler.java
private long scaleDownSNF(final SimpleString address, final Set<Queue> queues, final ClientProducer producer) throws Exception {
    long messageCount = 0;
    final String propertyEnd;
    // If this SNF is towards our targetNodeId
    boolean queueOnTarget = address.toString().endsWith(targetNodeId);
    if (queueOnTarget) {
        propertyEnd = targetNodeId;
    } else {
        propertyEnd = address.toString().substring(address.toString().lastIndexOf("."));
    }
    Transaction tx = new TransactionImpl(storageManager);
    for (Queue queue : queues) {
        // using auto-closeable
        try (LinkedListIterator<MessageReference> messagesIterator = queue.totalIterator()) {
            // loop through every message of this queue
            while (messagesIterator.hasNext()) {
                MessageReference messageRef = messagesIterator.next();
                Message message = messageRef.getMessage().copy();
                /* Here we are taking messages out of a store-and-forward queue and sending them to the corresponding
                * address on the scale-down target server.  However, we have to take the existing _AMQ_ROUTE_TOsf.*
                * property and put its value into the _AMQ_ROUTE_TO property so the message is routed properly.
                */
                byte[] oldRouteToIDs = null;
                List<SimpleString> propertiesToRemove = new ArrayList<>();
                message.removeProperty(MessageImpl.HDR_ROUTE_TO_IDS);
                for (SimpleString propName : message.getPropertyNames()) {
                    if (propName.startsWith(MessageImpl.HDR_ROUTE_TO_IDS)) {
                        if (propName.toString().endsWith(propertyEnd)) {
                            oldRouteToIDs = message.getBytesProperty(propName);
                        }
                        propertiesToRemove.add(propName);
                    }
                }
                for (SimpleString propertyToRemove : propertiesToRemove) {
                    message.removeProperty(propertyToRemove);
                }
                if (queueOnTarget) {
                    message.putBytesProperty(MessageImpl.HDR_ROUTE_TO_IDS, oldRouteToIDs);
                } else {
                    message.putBytesProperty(MessageImpl.HDR_SCALEDOWN_TO_IDS, oldRouteToIDs);
                }
                logger.debug("Scaling down message " + message + " from " + address + " to " + message.getAddress() + " on node " + targetNodeId);
                producer.send(message.getAddress(), message);
                messageCount++;
                messagesIterator.remove();
                ackMessageOnQueue(tx, queue, messageRef);
            }
        }
    }
    tx.commit();
    return messageCount;
}

81. PostOfficeJournalLoader#handlePreparedSendMessage()

Project: activemq-artemis
File: PostOfficeJournalLoader.java
@Override
public void handlePreparedSendMessage(ServerMessage message, Transaction tx, long queueID) throws Exception {
    Queue queue = queues.get(queueID);
    if (queue == null) {
        ActiveMQServerLogger.LOGGER.journalMessageInPreparedTX(queueID);
        return;
    }
    postOffice.reroute(message, queue, tx);
}

82. ActiveMQServerImpl#createQueue()

Project: activemq-artemis
File: ActiveMQServerImpl.java
private Queue createQueue(final SimpleString address, final SimpleString queueName, final SimpleString filterString, final SimpleString user, final boolean durable, final boolean temporary, final boolean ignoreIfExists, final boolean transientQueue, final boolean autoCreated) throws Exception {
    QueueBinding binding = (QueueBinding) postOffice.getBinding(queueName);
    if (binding != null) {
        if (ignoreIfExists) {
            return binding.getQueue();
        } else {
            throw ActiveMQMessageBundle.BUNDLE.queueAlreadyExists(queueName);
        }
    }
    Filter filter = FilterImpl.createFilter(filterString);
    long txID = storageManager.generateID();
    long queueID = storageManager.generateID();
    PageSubscription pageSubscription;
    if (filterString != null && filterString.toString().equals(GENERIC_IGNORED_FILTER)) {
        pageSubscription = null;
    } else {
        pageSubscription = pagingManager.getPageStore(address).getCursorProvider().createSubscription(queueID, filter, durable);
    }
    final Queue queue = queueFactory.createQueue(queueID, address, queueName, filter, pageSubscription, user, durable, temporary, autoCreated);
    if (transientQueue) {
        queue.setConsumersRefCount(new TransientQueueManagerImpl(this, queueName));
    } else if (autoCreated) {
        queue.setConsumersRefCount(new AutoCreatedQueueManagerImpl(this.getJMSQueueDeleter(), queueName));
    }
    binding = new LocalQueueBinding(address, queue, nodeManager.getNodeId());
    if (durable) {
        storageManager.addQueueBinding(txID, binding);
    }
    try {
        postOffice.addBinding(binding);
        if (durable) {
            storageManager.commitBindings(txID);
        }
    } catch (Exception e) {
        try {
            if (durable) {
                storageManager.rollbackBindings(txID);
            }
            if (queue != null) {
                queue.close();
            }
            if (pageSubscription != null) {
                pageSubscription.destroy();
            }
        } catch (Throwable ignored) {
            logger.debug(ignored.getMessage(), ignored);
        }
        throw e;
    }
    managementService.registerAddress(address);
    managementService.registerQueue(queue, address, storageManager);
    callPostQueueCreationCallbacks(queueName);
    return queue;
}

83. BridgeImpl#cancelRefs()

Project: activemq-artemis
File: BridgeImpl.java
private void cancelRefs() {
    LinkedList<MessageReference> list = new LinkedList<>();
    synchronized (refs) {
        list.addAll(refs.values());
        refs.clear();
    }
    if (logger.isTraceEnabled()) {
        logger.trace("BridgeImpl::cancelRefs cancelling " + list.size() + " references");
    }
    if (logger.isTraceEnabled() && list.isEmpty()) {
        logger.trace("didn't have any references to cancel on bridge " + this);
        return;
    }
    ListIterator<MessageReference> listIterator = list.listIterator(list.size());
    Queue refqueue;
    long timeBase = System.currentTimeMillis();
    while (listIterator.hasPrevious()) {
        MessageReference ref = listIterator.previous();
        if (logger.isTraceEnabled()) {
            logger.trace("BridgeImpl::cancelRefs Cancelling reference " + ref + " on bridge " + this);
        }
        refqueue = ref.getQueue();
        try {
            refqueue.cancel(ref, timeBase);
        } catch (Exception e) {
            ActiveMQServerLogger.LOGGER.errorCancellingRefOnBridge(e, ref);
        }
    }
}

84. ClusterManager#deployBridge()

Project: activemq-artemis
File: ClusterManager.java
public synchronized void deployBridge(final BridgeConfiguration config) throws Exception {
    if (config.getName() == null) {
        ActiveMQServerLogger.LOGGER.bridgeNotUnique();
        return;
    }
    if (config.getQueueName() == null) {
        ActiveMQServerLogger.LOGGER.bridgeNoQueue(config.getName());
        return;
    }
    if (config.getForwardingAddress() == null) {
        ActiveMQServerLogger.LOGGER.bridgeNoForwardAddress(config.getName());
    }
    if (bridges.containsKey(config.getName())) {
        ActiveMQServerLogger.LOGGER.bridgeAlreadyDeployed(config.getName());
        return;
    }
    Transformer transformer = server.getServiceRegistry().getBridgeTransformer(config.getName(), config.getTransformerClassName());
    Binding binding = postOffice.getBinding(new SimpleString(config.getQueueName()));
    if (binding == null) {
        ActiveMQServerLogger.LOGGER.bridgeQueueNotFound(config.getQueueName(), config.getName());
        return;
    }
    Queue queue = (Queue) binding.getBindable();
    ServerLocatorInternal serverLocator;
    if (config.getDiscoveryGroupName() != null) {
        DiscoveryGroupConfiguration discoveryGroupConfiguration = configuration.getDiscoveryGroupConfigurations().get(config.getDiscoveryGroupName());
        if (discoveryGroupConfiguration == null) {
            ActiveMQServerLogger.LOGGER.bridgeNoDiscoveryGroup(config.getDiscoveryGroupName());
            return;
        }
        if (config.isHA()) {
            serverLocator = (ServerLocatorInternal) ActiveMQClient.createServerLocatorWithHA(discoveryGroupConfiguration);
        } else {
            serverLocator = (ServerLocatorInternal) ActiveMQClient.createServerLocatorWithoutHA(discoveryGroupConfiguration);
        }
    } else {
        TransportConfiguration[] tcConfigs = configuration.getTransportConfigurations(config.getStaticConnectors());
        if (tcConfigs == null) {
            ActiveMQServerLogger.LOGGER.bridgeCantFindConnectors(config.getName());
            return;
        }
        if (config.isHA()) {
            serverLocator = (ServerLocatorInternal) ActiveMQClient.createServerLocatorWithHA(tcConfigs);
        } else {
            serverLocator = (ServerLocatorInternal) ActiveMQClient.createServerLocatorWithoutHA(tcConfigs);
        }
    }
    serverLocator.setIdentity("Bridge " + config.getName());
    serverLocator.setConfirmationWindowSize(config.getConfirmationWindowSize());
    // We are going to manually retry on the bridge in case of failure
    serverLocator.setReconnectAttempts(0);
    serverLocator.setInitialConnectAttempts(0);
    serverLocator.setRetryInterval(config.getRetryInterval());
    serverLocator.setMaxRetryInterval(config.getMaxRetryInterval());
    serverLocator.setRetryIntervalMultiplier(config.getRetryIntervalMultiplier());
    serverLocator.setClientFailureCheckPeriod(config.getClientFailureCheckPeriod());
    serverLocator.setConnectionTTL(config.getConnectionTTL());
    serverLocator.setBlockOnDurableSend(!config.isUseDuplicateDetection());
    serverLocator.setBlockOnNonDurableSend(!config.isUseDuplicateDetection());
    serverLocator.setMinLargeMessageSize(config.getMinLargeMessageSize());
    serverLocator.setProducerWindowSize(config.getProducerWindowSize());
    // This will be set to 30s unless it's changed from embedded / testing
    // there is no reason to exception the config for this timeout
    // since the Bridge is supposed to be non-blocking and fast
    // We may expose this if we find a good use case
    serverLocator.setCallTimeout(config.getCallTimeout());
    serverLocator.addIncomingInterceptor(new IncomingInterceptorLookingForExceptionMessage(this, executor));
    if (!config.isUseDuplicateDetection()) {
        logger.debug("Bridge " + config.getName() + " is configured to not use duplicate detecion, it will send messages synchronously");
    }
    clusterLocators.add(serverLocator);
    Bridge bridge = new BridgeImpl(serverLocator, config.getInitialConnectAttempts(), config.getReconnectAttempts(), config.getReconnectAttemptsOnSameNode(), config.getRetryInterval(), config.getRetryIntervalMultiplier(), config.getMaxRetryInterval(), nodeManager.getUUID(), new SimpleString(config.getName()), queue, executorFactory.getExecutor(), FilterImpl.createFilter(config.getFilterString()), SimpleString.toSimpleString(config.getForwardingAddress()), scheduledExecutor, transformer, config.isUseDuplicateDetection(), config.getUser(), config.getPassword(), server.getStorageManager());
    bridges.put(config.getName(), bridge);
    managementService.registerBridge(bridge, config);
    bridge.start();
}

85. PostOfficeImpl#sendQueueInfoToQueue()

Project: activemq-artemis
File: PostOfficeImpl.java
@Override
public void sendQueueInfoToQueue(final SimpleString queueName, final SimpleString address) throws Exception {
    // We send direct to the queue so we can send it to the same queue that is bound to the notifications address -
    // this is crucial for ensuring
    // that queue infos and notifications are received in a contiguous consistent stream
    Binding binding = addressManager.getBinding(queueName);
    if (binding == null) {
        throw new IllegalStateException("Cannot find queue " + queueName);
    }
    if (logger.isDebugEnabled()) {
        logger.debug("PostOffice.sendQueueInfoToQueue on server=" + this.server + ", queueName=" + queueName + " and address=" + address);
    }
    Queue queue = (Queue) binding.getBindable();
    // Need to lock to make sure all queue info and notifications are in the correct order with no gaps
    synchronized (notificationLock) {
        // First send a reset message
        ServerMessage message = new ServerMessageImpl(storageManager.generateID(), 50);
        message.setAddress(queueName);
        message.putBooleanProperty(PostOfficeImpl.HDR_RESET_QUEUE_DATA, true);
        routeQueueInfo(message, queue, false);
        for (QueueInfo info : queueInfos.values()) {
            if (logger.isTraceEnabled()) {
                logger.trace("QueueInfo on sendQueueInfoToQueue = " + info);
            }
            if (info.matchesAddress(address)) {
                message = createQueueInfoMessage(CoreNotificationType.BINDING_ADDED, queueName);
                message.putStringProperty(ManagementHelper.HDR_ADDRESS, info.getAddress());
                message.putStringProperty(ManagementHelper.HDR_CLUSTER_NAME, info.getClusterName());
                message.putStringProperty(ManagementHelper.HDR_ROUTING_NAME, info.getRoutingName());
                message.putLongProperty(ManagementHelper.HDR_BINDING_ID, info.getID());
                message.putStringProperty(ManagementHelper.HDR_FILTERSTRING, info.getFilterString());
                message.putIntProperty(ManagementHelper.HDR_DISTANCE, info.getDistance());
                routeQueueInfo(message, queue, true);
                int consumersWithFilters = info.getFilterStrings() != null ? info.getFilterStrings().size() : 0;
                for (int i = 0; i < info.getNumberOfConsumers() - consumersWithFilters; i++) {
                    message = createQueueInfoMessage(CoreNotificationType.CONSUMER_CREATED, queueName);
                    message.putStringProperty(ManagementHelper.HDR_ADDRESS, info.getAddress());
                    message.putStringProperty(ManagementHelper.HDR_CLUSTER_NAME, info.getClusterName());
                    message.putStringProperty(ManagementHelper.HDR_ROUTING_NAME, info.getRoutingName());
                    message.putIntProperty(ManagementHelper.HDR_DISTANCE, info.getDistance());
                    routeQueueInfo(message, queue, true);
                }
                if (info.getFilterStrings() != null) {
                    for (SimpleString filterString : info.getFilterStrings()) {
                        message = createQueueInfoMessage(CoreNotificationType.CONSUMER_CREATED, queueName);
                        message.putStringProperty(ManagementHelper.HDR_ADDRESS, info.getAddress());
                        message.putStringProperty(ManagementHelper.HDR_CLUSTER_NAME, info.getClusterName());
                        message.putStringProperty(ManagementHelper.HDR_ROUTING_NAME, info.getRoutingName());
                        message.putStringProperty(ManagementHelper.HDR_FILTERSTRING, filterString);
                        message.putIntProperty(ManagementHelper.HDR_DISTANCE, info.getDistance());
                        routeQueueInfo(message, queue, true);
                    }
                }
            }
        }
        ServerMessage completeMessage = new ServerMessageImpl(storageManager.generateID(), 50);
        completeMessage.setAddress(queueName);
        completeMessage.putBooleanProperty(PostOfficeImpl.HDR_RESET_QUEUE_DATA_COMPLETE, true);
        routeQueueInfo(completeMessage, queue, false);
    }
}

86. MQTTSubscriptionManager#createQueueForSubscription()

Project: activemq-artemis
File: MQTTSubscriptionManager.java
/**
    * Creates a Queue if it doesn't already exist, based on a topic and address.  Returning the queue name.
    */
private SimpleString createQueueForSubscription(String topic, int qos) throws Exception {
    String address = MQTTUtil.convertMQTTAddressFilterToCore(topic);
    SimpleString queue = getQueueNameForTopic(address);
    Queue q = session.getServer().locateQueue(queue);
    if (q == null) {
        session.getServerSession().createQueue(new SimpleString(address), queue, null, false, MQTTUtil.DURABLE_MESSAGES && qos >= 0);
    }
    return queue;
}

87. 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();
    }
}

88. RemoteQueueBindImplTest#testAddRemoveConsumer()

Project: activemq-artemis
File: RemoteQueueBindImplTest.java
// Constants -----------------------------------------------------
// Attributes ----------------------------------------------------
// Static --------------------------------------------------------
// Constructors --------------------------------------------------
// Public --------------------------------------------------------
@Test
public void testAddRemoveConsumer() throws Exception {
    final long id = RandomUtil.randomLong();
    final SimpleString address = RandomUtil.randomSimpleString();
    final SimpleString uniqueName = RandomUtil.randomSimpleString();
    final SimpleString routingName = RandomUtil.randomSimpleString();
    final Long remoteQueueID = RandomUtil.randomLong();
    final SimpleString filterString = new SimpleString("A>B");
    final Queue storeAndForwardQueue = new FakeQueue(null);
    final SimpleString bridgeName = RandomUtil.randomSimpleString();
    final int distance = 0;
    RemoteQueueBindingImpl binding = new RemoteQueueBindingImpl(id, address, uniqueName, routingName, remoteQueueID, filterString, storeAndForwardQueue, bridgeName, distance);
    for (int i = 0; i < 100; i++) {
        binding.addConsumer(new SimpleString("B" + i + "<A"));
    }
    assertEquals(100, binding.getFilters().size());
    for (int i = 0; i < 100; i++) {
        binding.removeConsumer(new SimpleString("B" + i + "<A"));
    }
    assertEquals(0, binding.getFilters().size());
}

89. BindingsImplTest#internalTest()

Project: activemq-artemis
File: BindingsImplTest.java
private void internalTest(final boolean route) throws Exception {
    final FakeBinding fake = new FakeBinding(new SimpleString("a"));
    final Bindings bind = new BindingsImpl(null, null, null);
    bind.addBinding(fake);
    bind.addBinding(new FakeBinding(new SimpleString("a")));
    bind.addBinding(new FakeBinding(new SimpleString("a")));
    Thread t = new Thread() {

        @Override
        public void run() {
            try {
                bind.removeBinding(fake);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };
    Queue queue = new FakeQueue(new SimpleString("a"));
    t.start();
    for (int i = 0; i < 100; i++) {
        if (route) {
            bind.route(new ServerMessageImpl(i, 100), new RoutingContextImpl(new FakeTransaction()));
        } else {
            bind.redistribute(new ServerMessageImpl(i, 100), queue, new RoutingContextImpl(new FakeTransaction()));
        }
    }
}

90. PageCursorStressTest#generateCTX()

Project: activemq-artemis
File: PageCursorStressTest.java
private RoutingContextImpl generateCTX(Transaction tx) {
    RoutingContextImpl ctx = new RoutingContextImpl(tx);
    ctx.addQueue(ADDRESS, queue);
    for (Queue q : this.queueList) {
        ctx.addQueue(ADDRESS, q);
    }
    return ctx;
}

91. LVQTest#testMultipleAcksPersistedCorrectly2()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testMultipleAcksPersistedCorrectly2() throws Exception {
    Queue queue = server.locateQueue(qName1);
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    SimpleString rh = new SimpleString("SMID1");
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m1.setDurable(true);
    ClientMessage m2 = createTextMessage(clientSession, "m2");
    m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m2.setDurable(true);
    clientSession.start();
    producer.send(m1);
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
    producer.send(m2);
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m2");
    assertEquals(0, queue.getDeliveringCount());
}

92. LVQTest#testScheduledMessages()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testScheduledMessages() throws Exception {
    final long DELAY_TIME = 5000;
    final int MESSAGE_COUNT = 5;
    Queue queue = server.locateQueue(qName1);
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    SimpleString rh = new SimpleString("SMID1");
    long timeSent = 0;
    for (int i = 0; i < MESSAGE_COUNT; i++) {
        ClientMessage m = createTextMessage(clientSession, "m" + i);
        m.setDurable(true);
        m.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
        timeSent = System.currentTimeMillis();
        m.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, timeSent + DELAY_TIME);
        producer.send(m);
        Thread.sleep(100);
    }
    // allow schedules to elapse so the messages will be delivered to the queue
    long start = System.currentTimeMillis();
    while (queue.getScheduledCount() > 0 && System.currentTimeMillis() - start <= DELAY_TIME) {
        Thread.sleep(50);
    }
    assertTrue(queue.getScheduledCount() == 0);
    clientSession.start();
    ClientMessage m = consumer.receive(DELAY_TIME);
    assertNotNull(m);
    long actualDelay = System.currentTimeMillis() - timeSent + 50;
    assertTrue(actualDelay >= DELAY_TIME);
    m.acknowledge();
    assertEquals(m.getBodyBuffer().readString(), "m" + (MESSAGE_COUNT - 1));
    assertEquals(0, queue.getScheduledCount());
}

93. LVQTest#testMultipleAcksPersistedCorrectly()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testMultipleAcksPersistedCorrectly() throws Exception {
    Queue queue = server.locateQueue(qName1);
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    SimpleString rh = new SimpleString("SMID1");
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m1.setDurable(true);
    ClientMessage m2 = createTextMessage(clientSession, "m2");
    m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m2.setDurable(true);
    ClientMessage m3 = createTextMessage(clientSession, "m3");
    m3.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m3.setDurable(true);
    ClientMessage m4 = createTextMessage(clientSession, "m4");
    m4.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m4.setDurable(true);
    ClientMessage m5 = createTextMessage(clientSession, "m5");
    m5.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m5.setDurable(true);
    ClientMessage m6 = createTextMessage(clientSession, "m6");
    m6.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m6.setDurable(true);
    clientSession.start();
    producer.send(m1);
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
    producer.send(m2);
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m2");
    producer.send(m3);
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m3");
    producer.send(m4);
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m4");
    producer.send(m5);
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m5");
    producer.send(m6);
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m6");
    assertEquals(0, queue.getDeliveringCount());
}

94. ProtonTest#testMessagesReceivedInParallel()

Project: activemq-artemis
File: ProtonTest.java
@Test
public void testMessagesReceivedInParallel() throws Throwable {
    final int numMessages = 50000;
    long time = System.currentTimeMillis();
    final javax.jms.Queue queue = createQueue(address);
    final ArrayList<Throwable> exceptions = new ArrayList<>();
    Thread t = new Thread(new Runnable() {

        @Override
        public void run() {
            Connection connectionConsumer = null;
            try {
                // TODO the test may starve if using the same connection (dead lock maybe?)
                connectionConsumer = createConnection();
                //               connectionConsumer = connection;
                connectionConsumer.start();
                Session sessionConsumer = connectionConsumer.createSession(false, Session.AUTO_ACKNOWLEDGE);
                final MessageConsumer consumer = sessionConsumer.createConsumer(queue);
                long n = 0;
                int count = numMessages;
                while (count > 0) {
                    try {
                        if (++n % 1000 == 0) {
                            System.out.println("received " + n + " messages");
                        }
                        Message m = consumer.receive(5000);
                        Assert.assertNotNull("Could not receive message count=" + count + " on consumer", m);
                        count--;
                    } catch (JMSException e) {
                        e.printStackTrace();
                        break;
                    }
                }
            } catch (Throwable e) {
                exceptions.add(e);
                e.printStackTrace();
            } finally {
                try {
                    // if the createconnecion wasn't commented out
                    if (connectionConsumer != connection) {
                        connectionConsumer.close();
                    }
                } catch (Throwable ignored) {
                }
            }
        }
    });
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    t.start();
    MessageProducer p = session.createProducer(queue);
    p.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
    for (int i = 0; i < numMessages; i++) {
        BytesMessage message = session.createBytesMessage();
        message.writeUTF("Hello world!!!!" + i);
        message.setIntProperty("count", i);
        p.send(message);
    }
    t.join();
    for (Throwable e : exceptions) {
        throw e;
    }
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(coreAddress)).getBindable();
    connection.close();
    Assert.assertEquals(0, getMessageCount(q));
    long taken = (System.currentTimeMillis() - time);
    System.out.println("Microbenchamrk ran in " + taken + " milliseconds, sending/receiving " + numMessages);
    double messagesPerSecond = ((double) numMessages / (double) taken) * 1000;
    System.out.println(((int) messagesPerSecond) + " messages per second");
}

95. ProtonTest#testClientAckMessages()

Project: activemq-artemis
File: ProtonTest.java
@Test
public void testClientAckMessages() throws Exception {
    int numMessages = 10;
    long time = System.currentTimeMillis();
    javax.jms.Queue queue = createQueue(address);
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageProducer p = session.createProducer(queue);
    byte[] bytes = new byte[2048];
    new Random().nextBytes(bytes);
    for (int i = 0; i < numMessages; i++) {
        TextMessage message = session.createTextMessage();
        message.setText("msg:" + i);
        p.send(message);
    }
    connection.close();
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(coreAddress)).getBindable();
    for (long timeout = System.currentTimeMillis() + 5000; timeout > System.currentTimeMillis() && getMessageCount(q) != numMessages; ) {
        Thread.sleep(1);
    }
    Assert.assertEquals(numMessages, getMessageCount(q));
    //now create a new connection and receive
    connection = createConnection();
    session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
    MessageConsumer consumer = session.createConsumer(queue);
    for (int i = 0; i < numMessages; i++) {
        Message msg = consumer.receive(5000);
        if (msg == null) {
            System.out.println("ProtonTest.testManyMessages");
        }
        Assert.assertNotNull("" + i, msg);
        Assert.assertTrue("" + msg, msg instanceof TextMessage);
        String text = ((TextMessage) msg).getText();
        //System.out.println("text = " + text);
        Assert.assertEquals(text, "msg:" + i);
        msg.acknowledge();
    }
    consumer.close();
    connection.close();
    Assert.assertEquals(0, getMessageCount(q));
    long taken = (System.currentTimeMillis() - time) / 1000;
    System.out.println("taken = " + taken);
}

96. ProtonTest#testCancelMessages()

Project: activemq-artemis
File: ProtonTest.java
@Test
public void testCancelMessages() throws Exception {
    int numMessages = 10;
    long time = System.currentTimeMillis();
    javax.jms.Queue queue = createQueue(address);
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageProducer p = session.createProducer(queue);
    byte[] bytes = new byte[2048];
    new Random().nextBytes(bytes);
    for (int i = 0; i < numMessages; i++) {
        TextMessage message = session.createTextMessage();
        message.setText("msg:" + i);
        p.send(message);
    }
    connection.close();
    Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(coreAddress)).getBindable();
    for (long timeout = System.currentTimeMillis() + 5000; timeout > System.currentTimeMillis() && getMessageCount(q) != numMessages; ) {
        Thread.sleep(1);
    }
    Assert.assertEquals(numMessages, getMessageCount(q));
    //now create a new connection and receive
    connection = createConnection();
    session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageConsumer consumer = session.createConsumer(queue);
    Thread.sleep(100);
    consumer.close();
    connection.close();
    Assert.assertEquals(numMessages, getMessageCount(q));
    long taken = (System.currentTimeMillis() - time) / 1000;
    System.out.println("taken = " + taken);
}

97. DeleteMessagesOnStartupTest#testDeleteMessagesOnStartup()

Project: activemq-artemis
File: DeleteMessagesOnStartupTest.java
@Test
public void testDeleteMessagesOnStartup() throws Exception {
    createStorage();
    Queue theQueue = new FakeQueue(new SimpleString(""));
    HashMap<Long, Queue> queues = new HashMap<>();
    queues.put(100L, theQueue);
    ServerMessage msg = new ServerMessageImpl(1, 100);
    journal.storeMessage(msg);
    for (int i = 2; i < 100; i++) {
        journal.storeMessage(new ServerMessageImpl(i, 100));
    }
    journal.storeReference(100, 1, true);
    journal.stop();
    journal.start();
    journal.loadBindingJournal(new ArrayList<QueueBindingInfo>(), new ArrayList<GroupingInfo>());
    FakePostOffice postOffice = new FakePostOffice();
    journal.loadMessageJournal(postOffice, null, null, null, null, null, null, new PostOfficeJournalLoader(postOffice, null, journal, null, null, null, null, null, queues));
    Assert.assertEquals(98, deletedMessage.size());
    for (Long messageID : deletedMessage) {
        Assert.assertTrue("messageID = " + messageID, messageID.longValue() >= 2 && messageID <= 99);
    }
}

98. PagingWithFailoverAndCountersTest#verifyServer()

Project: activemq-artemis
File: PagingWithFailoverAndCountersTest.java
public void verifyServer() throws Exception {
    ServerLocator locator;
    ClientSessionFactory factory;
    ClientSession session;
    ActiveMQServer server = PagingWithFailoverServer.createServer(getTestDir(), PORT1, PORT2, false);
    server.start();
    waitForServerToStart(server);
    Queue queue = server.locateQueue(SimpleString.toSimpleString("cons2"));
    int messageCount = getMessageCount(queue);
    assertTrue(messageCount >= 0);
    locator = SpawnedServerSupport.createLocator(PORT1).setInitialConnectAttempts(100).setReconnectAttempts(-1).setRetryInterval(100);
    factory = locator.createSessionFactory();
    session = factory.createSession();
    session.start();
    try {
        drainConsumer(session.createConsumer("cons2"), "cons2", messageCount);
    } finally {
        session.close();
        factory.close();
        locator.close();
        server.stop();
    }
}

99. 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));
    }
}

100. 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));
    }
}