Examples with ProducerBrokerExchange org.apache.activemq.broker.ProducerBrokerExchange used on opensource projects

Example 1 with ProducerBrokerExchange

use of org.apache.activemq.broker.ProducerBrokerExchange in project activemq-artemis by apache.

the class TwoBrokerQueueClientsReconnectTest method testDuplicateSendWithNoAuditEnqueueCountStat.

public void testDuplicateSendWithNoAuditEnqueueCountStat() throws Exception {
    broker1 = "BrokerA";
    broker2 = "BrokerB";
    NetworkConnector networkConnector = bridgeBrokers(broker1, broker2);
    final AtomicBoolean first = new AtomicBoolean();
    final CountDownLatch gotMessageLatch = new CountDownLatch(1);
    BrokerService brokerService = brokers.get(broker2).broker;
    brokerService.setPersistent(true);
    brokerService.setDeleteAllMessagesOnStartup(true);
    // disable concurrent dispatch otherwise store duplicate suppression will be skipped b/c cursor audit is already
    // disabled so verification of stats will fail - ie: duplicate will be dispatched
    ((KahaDBPersistenceAdapter) brokerService.getPersistenceAdapter()).setConcurrentStoreAndDispatchQueues(false);
    brokerService.setPlugins(new BrokerPlugin[] { new BrokerPluginSupport() {

        @Override
        public void send(final ProducerBrokerExchange producerExchange, org.apache.activemq.command.Message messageSend) throws Exception {
            super.send(producerExchange, messageSend);
            if (first.compareAndSet(false, true)) {
                producerExchange.getConnectionContext().setDontSendReponse(true);
                new Thread() {

                    @Override
                    public void run() {
                        try {
                            LOG.info("Waiting for recepit");
                            assertTrue("message received on time", gotMessageLatch.await(60, TimeUnit.SECONDS));
                            LOG.info("Stopping connection post send and receive and multiple producers");
                            producerExchange.getConnectionContext().getConnection().stop();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }.start();
            }
        }
    } });
    // Create queue
    ActiveMQDestination dest = createDestination("TEST.FOO", false);
    // statically include our destination
    networkConnector.addStaticallyIncludedDestination(dest);
    // Run brokers
    startAllBrokers();
    waitForBridgeFormation();
    sendMessages("BrokerA", dest, 1);
    // wait for broker2 to get the initial forward
    Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisified() throws Exception {
            return brokers.get(broker2).broker.getAdminView().getTotalMessageCount() == 1;
        }
    });
    // message still pending on broker1
    assertEquals("messages message still there", 1, brokers.get(broker1).broker.getAdminView().getTotalMessageCount());
    // allow the bridge to be shutdown and restarted
    gotMessageLatch.countDown();
    // verify message is forwarded after restart
    assertTrue("no messages enqueued on origin", Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisified() throws Exception {
            return 0 == brokers.get(broker1).broker.getAdminView().getTotalMessageCount();
        }
    }));
    assertEquals("one messages pending", 1, brokers.get(broker2).broker.getAdminView().getTotalMessageCount());
    assertEquals("one messages enqueued", 1, brokers.get(broker2).broker.getDestination(dest).getDestinationStatistics().getEnqueues().getCount());
}

Example 2 with ProducerBrokerExchange

use of org.apache.activemq.broker.ProducerBrokerExchange in project activemq-artemis by apache.

the class TwoBrokerQueueClientsReconnectTest method testDuplicateSend.

public void testDuplicateSend() throws Exception {
    broker1 = "BrokerA";
    broker2 = "BrokerB";
    // enable producer audit for the network connector, off by default b/c of interference with composite
    // dests and virtual topics
    brokers.get(broker2).broker.getTransportConnectors().get(0).setAuditNetworkProducers(true);
    bridgeBrokers(broker1, broker2);
    final AtomicBoolean first = new AtomicBoolean();
    final CountDownLatch gotMessageLatch = new CountDownLatch(1);
    BrokerService brokerService = brokers.get(broker2).broker;
    brokerService.setPersistent(true);
    brokerService.setDeleteAllMessagesOnStartup(true);
    brokerService.setPlugins(new BrokerPlugin[] { new BrokerPluginSupport() {

        @Override
        public void send(final ProducerBrokerExchange producerExchange, org.apache.activemq.command.Message messageSend) throws Exception {
            super.send(producerExchange, messageSend);
            if (first.compareAndSet(false, true)) {
                producerExchange.getConnectionContext().setDontSendReponse(true);
                new Thread() {

                    @Override
                    public void run() {
                        try {
                            LOG.info("Waiting for recepit");
                            assertTrue("message received on time", gotMessageLatch.await(60, TimeUnit.SECONDS));
                            LOG.info("Stopping connection post send and receive and multiple producers");
                            producerExchange.getConnectionContext().getConnection().stop();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }.start();
            }
        }
    } });
    // Run brokers
    startAllBrokers();
    waitForBridgeFormation();
    // Create queue
    Destination dest = createDestination("TEST.FOO", false);
    MessageConsumer client2 = createConsumer(broker2, dest);
    sendMessages("BrokerA", dest, 1);
    assertEquals("Client got message", 1, receiveExactMessages(client2, 1));
    client2.close();
    gotMessageLatch.countDown();
    // message still pending on broker1
    assertEquals("messages message still there", 1, brokers.get(broker1).broker.getAdminView().getTotalMessageCount());
    client2 = createConsumer(broker2, dest);
    LOG.info("Let the second client receive the rest of the messages");
    assertEquals("no duplicate message", 0, receiveAllMessages(client2));
    assertEquals("no duplicate message", 0, receiveAllMessages(client2));
    assertEquals("no messages enqueued", 0, brokers.get(broker2).broker.getAdminView().getTotalMessageCount());
    assertTrue("no messages enqueued on origin", Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisified() throws Exception {
            return 0 == brokers.get(broker1).broker.getAdminView().getTotalMessageCount();
        }
    }));
}

Example 3 with ProducerBrokerExchange

use of org.apache.activemq.broker.ProducerBrokerExchange in project activemq-artemis by apache.

the class QueueOptimizedDispatchExceptionTest method TestOptimizedDispatchCME.

@Test
public void TestOptimizedDispatchCME() throws Exception {
    final PersistenceAdapter persistenceAdapter = broker.getPersistenceAdapter();
    final MessageStore queueMessageStore = persistenceAdapter.createQueueMessageStore(destination);
    final ConnectionContext contextNotInTx = new ConnectionContext();
    contextNotInTx.setConnection(new Connection() {

        @Override
        public void stop() throws Exception {
        }

        @Override
        public void start() throws Exception {
        }

        @Override
        public void updateClient(ConnectionControl control) {
        }

        @Override
        public void serviceExceptionAsync(IOException e) {
        }

        @Override
        public void serviceException(Throwable error) {
        }

        @Override
        public Response service(Command command) {
            return null;
        }

        @Override
        public boolean isSlow() {
            return false;
        }

        @Override
        public boolean isNetworkConnection() {
            return false;
        }

        @Override
        public boolean isManageable() {
            return false;
        }

        @Override
        public boolean isFaultTolerantConnection() {
            return false;
        }

        @Override
        public boolean isConnected() {
            return true;
        }

        @Override
        public boolean isBlocked() {
            return false;
        }

        @Override
        public boolean isActive() {
            return false;
        }

        @Override
        public ConnectionStatistics getStatistics() {
            return null;
        }

        @Override
        public String getRemoteAddress() {
            return null;
        }

        @Override
        public int getDispatchQueueSize() {
            return 0;
        }

        @Override
        public Connector getConnector() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public String getConnectionId() {
            return null;
        }

        @Override
        public void dispatchSync(Command message) {
        }

        @Override
        public void dispatchAsync(Command command) {
        }

        @Override
        public int getActiveTransactionCount() {
            return 0;
        }

        @Override
        public Long getOldestActiveTransactionDuration() {
            return null;
        }
    });
    final DestinationStatistics destinationStatistics = new DestinationStatistics();
    final Queue queue = new Queue(broker, destination, queueMessageStore, destinationStatistics, broker.getTaskRunnerFactory());
    final MockMemoryUsage usage = new MockMemoryUsage();
    queue.setOptimizedDispatch(true);
    queue.initialize();
    queue.start();
    queue.memoryUsage = usage;
    ProducerBrokerExchange producerExchange = new ProducerBrokerExchange();
    ProducerInfo producerInfo = new ProducerInfo();
    ProducerState producerState = new ProducerState(producerInfo);
    producerExchange.setProducerState(producerState);
    producerExchange.setConnectionContext(contextNotInTx);
    // populate the queue store, exceed memory limit so that cache is disabled
    for (int i = 0; i < count; i++) {
        Message message = getMessage(i);
        queue.send(producerExchange, message);
    }
    usage.setFull(false);
    try {
        queue.wakeup();
    } catch (Exception e) {
        LOG.error("Queue threw an unexpected exception: " + e.toString());
        fail("Should not throw an exception.");
    }
}

Example 4 with ProducerBrokerExchange

use of org.apache.activemq.broker.ProducerBrokerExchange in project activemq-artemis by apache.

the class QueueDuplicatesFromStoreTest method doTestNoDuplicateAfterCacheFullAndAcked.

public void doTestNoDuplicateAfterCacheFullAndAcked(final int auditDepth) throws Exception {
    final PersistenceAdapter persistenceAdapter = brokerService.getPersistenceAdapter();
    final MessageStore queueMessageStore = persistenceAdapter.createQueueMessageStore(destination);
    final ConnectionContext contextNotInTx = new ConnectionContext();
    final ConsumerInfo consumerInfo = new ConsumerInfo();
    final DestinationStatistics destinationStatistics = new DestinationStatistics();
    consumerInfo.setExclusive(true);
    final Queue queue = new Queue(brokerService, destination, queueMessageStore, destinationStatistics, brokerService.getTaskRunnerFactory());
    // a workaround for this issue
    // queue.setUseCache(false);
    queue.systemUsage.getMemoryUsage().setLimit(1024 * 1024 * 10);
    queue.setMaxAuditDepth(auditDepth);
    queue.initialize();
    queue.start();
    ProducerBrokerExchange producerExchange = new ProducerBrokerExchange();
    ProducerInfo producerInfo = new ProducerInfo();
    ProducerState producerState = new ProducerState(producerInfo);
    producerExchange.setProducerState(producerState);
    producerExchange.setConnectionContext(contextNotInTx);
    final CountDownLatch receivedLatch = new CountDownLatch(count);
    final AtomicLong ackedCount = new AtomicLong(0);
    final AtomicLong enqueueCounter = new AtomicLong(0);
    final Vector<String> errors = new Vector<>();
    // populate the queue store, exceed memory limit so that cache is disabled
    for (int i = 0; i < count; i++) {
        Message message = getMessage(i);
        queue.send(producerExchange, message);
    }
    assertEquals("store count is correct", count, queueMessageStore.getMessageCount());
    // pull from store in small windows
    Subscription subscription = new Subscription() {

        private SubscriptionStatistics subscriptionStatistics = new SubscriptionStatistics();

        @Override
        public long getPendingMessageSize() {
            return 0;
        }

        @Override
        public void add(MessageReference node) throws Exception {
            if (enqueueCounter.get() != node.getMessageId().getProducerSequenceId()) {
                errors.add("Not in sequence at: " + enqueueCounter.get() + ", received: " + node.getMessageId().getProducerSequenceId());
            }
            assertEquals("is in order", enqueueCounter.get(), node.getMessageId().getProducerSequenceId());
            receivedLatch.countDown();
            enqueueCounter.incrementAndGet();
            node.decrementReferenceCount();
        }

        @Override
        public void add(ConnectionContext context, Destination destination) throws Exception {
        }

        @Override
        public int countBeforeFull() {
            if (isFull()) {
                return 0;
            } else {
                return fullWindow - (int) (enqueueCounter.get() - ackedCount.get());
            }
        }

        @Override
        public void destroy() {
        }

        @Override
        public void gc() {
        }

        @Override
        public ConsumerInfo getConsumerInfo() {
            return consumerInfo;
        }

        @Override
        public ConnectionContext getContext() {
            return null;
        }

        @Override
        public long getDequeueCounter() {
            return 0;
        }

        @Override
        public long getDispatchedCounter() {
            return 0;
        }

        @Override
        public int getDispatchedQueueSize() {
            return 0;
        }

        @Override
        public long getEnqueueCounter() {
            return 0;
        }

        @Override
        public int getInFlightSize() {
            return 0;
        }

        @Override
        public int getInFlightUsage() {
            return 0;
        }

        @Override
        public ObjectName getObjectName() {
            return null;
        }

        @Override
        public int getPendingQueueSize() {
            return 0;
        }

        @Override
        public int getPrefetchSize() {
            return 0;
        }

        @Override
        public String getSelector() {
            return null;
        }

        @Override
        public boolean isBrowser() {
            return false;
        }

        @Override
        public boolean isFull() {
            return (enqueueCounter.get() - ackedCount.get()) >= fullWindow;
        }

        @Override
        public boolean isHighWaterMark() {
            return false;
        }

        @Override
        public boolean isLowWaterMark() {
            return false;
        }

        @Override
        public boolean isRecoveryRequired() {
            return false;
        }

        @Override
        public boolean matches(MessageReference node, MessageEvaluationContext context) throws IOException {
            return true;
        }

        @Override
        public boolean matches(ActiveMQDestination destination) {
            return true;
        }

        @Override
        public void processMessageDispatchNotification(MessageDispatchNotification mdn) throws Exception {
        }

        @Override
        public Response pullMessage(ConnectionContext context, MessagePull pull) throws Exception {
            return null;
        }

        @Override
        public boolean isWildcard() {
            return false;
        }

        @Override
        public List<MessageReference> remove(ConnectionContext context, Destination destination) throws Exception {
            return null;
        }

        @Override
        public void setObjectName(ObjectName objectName) {
        }

        @Override
        public void setSelector(String selector) throws InvalidSelectorException, UnsupportedOperationException {
        }

        @Override
        public void updateConsumerPrefetch(int newPrefetch) {
        }

        @Override
        public boolean addRecoveredMessage(ConnectionContext context, MessageReference message) throws Exception {
            return false;
        }

        @Override
        public ActiveMQDestination getActiveMQDestination() {
            return destination;
        }

        @Override
        public void acknowledge(ConnectionContext context, MessageAck ack) throws Exception {
        }

        @Override
        public int getCursorMemoryHighWaterMark() {
            return 0;
        }

        @Override
        public void setCursorMemoryHighWaterMark(int cursorMemoryHighWaterMark) {
        }

        @Override
        public boolean isSlowConsumer() {
            return false;
        }

        @Override
        public void unmatched(MessageReference node) throws IOException {
        }

        @Override
        public long getTimeOfLastMessageAck() {
            return 0;
        }

        @Override
        public long getConsumedCount() {
            return 0;
        }

        @Override
        public void incrementConsumedCount() {
        }

        @Override
        public void resetConsumedCount() {
        }

        @Override
        public SubscriptionStatistics getSubscriptionStatistics() {
            return subscriptionStatistics;
        }

        @Override
        public long getInFlightMessageSize() {
            return subscriptionStatistics.getInflightMessageSize().getTotalSize();
        }
    };
    queue.addSubscription(contextNotInTx, subscription);
    int removeIndex = 0;
    do {
        // Simulate periodic acks in small but recent windows
        long receivedCount = enqueueCounter.get();
        if (receivedCount > ackStartIndex) {
            if (receivedCount >= removeIndex + ackWindow) {
                for (int j = 0; j < ackBatchSize; j++, removeIndex++) {
                    ackedCount.incrementAndGet();
                    MessageAck ack = new MessageAck();
                    ack.setLastMessageId(new MessageId(mesageIdRoot + removeIndex));
                    ack.setMessageCount(1);
                    queue.removeMessage(contextNotInTx, subscription, new IndirectMessageReference(getMessage(removeIndex)), ack);
                    queue.wakeup();
                }
                if (removeIndex % 1000 == 0) {
                    LOG.info("acked: " + removeIndex);
                    persistenceAdapter.checkpoint(true);
                }
            }
        }
    } while (!receivedLatch.await(0, TimeUnit.MILLISECONDS) && errors.isEmpty());
    assertTrue("There are no errors: " + errors, errors.isEmpty());
    assertEquals(count, enqueueCounter.get());
    assertEquals("store count is correct", count - removeIndex, queueMessageStore.getMessageCount());
}