@Override public void run() { try { session.sendAck(ackToSend,true); } catch (JMSException e) { LOG.error(getConsumerId() + " failed to delivered acknowledgements", e); } finally { deliveryingAcknowledgements.set(false); } } });
public String getConsumerId() { return consumer != null ? consumer.getConsumerId().toString() : "NOT_SET"; }
private void waitForRedeliveries() { if (failoverRedeliveryWaitPeriod > 0 && previouslyDeliveredMessages != null) { long expiry = System.currentTimeMillis() + failoverRedeliveryWaitPeriod; int numberNotReplayed; do { numberNotReplayed = 0; synchronized(deliveredMessages) { if (previouslyDeliveredMessages != null) { for (Entry<MessageId, Boolean> entry: previouslyDeliveredMessages.entrySet()) { if (!entry.getValue()) { numberNotReplayed++; } } } } if (numberNotReplayed > 0) { LOG.info("waiting for redelivery of {} in transaction: {}, to consumer: {}", numberNotReplayed, this.getConsumerId(), previouslyDeliveredMessages.transactionId); try { Thread.sleep(Math.max(500, failoverRedeliveryWaitPeriod/4)); } catch (InterruptedException outOfhere) { break; } } } while (numberNotReplayed > 0 && expiry - System.currentTimeMillis() < 0); } }
protected void close(ConsumerId id) { for (Iterator<ActiveMQMessageConsumer> iter = consumers.iterator(); iter.hasNext();) { ActiveMQMessageConsumer c = iter.next(); if (c.getConsumerId().equals(id)) { try { c.close(); } catch (JMSException e) { LOG.warn("Exception closing consumer", e); } LOG.warn("Closed consumer on Command, " + id); break; } } }
private void rollbackOnFailedRecoveryRedelivery() throws JMSException { if (previouslyDeliveredMessages != null) { // if any previously delivered messages was not re-delivered, transaction is invalid and must rollback // as messages have been dispatched else where. int numberNotReplayed = 0; for (Entry<MessageId, Boolean> entry: previouslyDeliveredMessages.entrySet()) { if (!entry.getValue()) { numberNotReplayed++; LOG.debug("previously delivered message has not been replayed in transaction: {}, messageId: {}", previouslyDeliveredMessages.transactionId, entry.getKey()); } } if (numberNotReplayed > 0) { String message = "rolling back transaction (" + previouslyDeliveredMessages.transactionId + ") post failover recovery. " + numberNotReplayed + " previously delivered message(s) not replayed to consumer: " + this.getConsumerId(); LOG.warn(message); throw new TransactionRolledBackException(message); } } }
protected void setPrefetchSize(ConsumerId id, int prefetch) { for (Iterator<ActiveMQMessageConsumer> iter = consumers.iterator(); iter.hasNext();) { ActiveMQMessageConsumer c = iter.next(); if (c.getConsumerId().equals(id)) { c.setPrefetchSize(prefetch); break; } } }
private ConsumerId redeliveryPendingInCompetingTransaction(MessageDispatch md) { for (ActiveMQSession activeMQSession: session.connection.getSessions()) { for (ActiveMQMessageConsumer activeMQMessageConsumer : activeMQSession.consumers) { if (activeMQMessageConsumer.redeliveryExpectedInCurrentTransaction(md, false)) { return activeMQMessageConsumer.getConsumerId(); } } } return null; }
/** * Add a message consumer. * * @param consumer - message consumer. * @throws JMSException */ protected void addConsumer(ActiveMQMessageConsumer consumer) throws JMSException { this.consumers.add(consumer); if (consumer.isDurableSubscriber()) { stats.onCreateDurableSubscriber(); } this.connection.addDispatcher(consumer.getConsumerId(), this); }
void doClose() throws JMSException { dispose(); RemoveInfo removeCommand = info.createRemoveCommand(); LOG.debug("remove: {}, lastDeliveredSequenceId: {}", getConsumerId(), lastDeliveredSequenceId); removeCommand.setLastDeliveredSequenceId(lastDeliveredSequenceId); this.session.asyncSendPacket(removeCommand); }
void dispatch(MessageDispatch message) { // TODO - we should use a Map for this indexed by consumerId for (ActiveMQMessageConsumer consumer : this.session.consumers) { ConsumerId consumerId = message.getConsumerId(); if (consumerId.equals(consumer.getConsumerId())) { consumer.dispatch(message); break; } } }
/** * Remove the message consumer. * * @param consumer - consumer to be removed. * @throws JMSException */ protected void removeConsumer(ActiveMQMessageConsumer consumer) { this.connection.removeDispatcher(consumer.getConsumerId()); if (consumer.isDurableSubscriber()) { stats.onRemoveDurableSubscriber(); } this.consumers.remove(consumer); this.connection.removeDispatcher(consumer); }
getConsumerId(), previouslyDeliveredMessages.transactionId, deliveredMessages.size()); } else { if (session.isClientAcknowledge()) { LOG.debug("{} rolling back delivered list ({}) on transport interrupt", getConsumerId(), deliveredMessages.size()); LOG.debug("{} clearing delivered list ({}) on transport interrupt", getConsumerId(), deliveredMessages.size()); deliveredMessages.clear(); pendingAck = null;
return null; } else if (consumeExpiredMessage(md)) { LOG.debug("{} received expired message: {}", getConsumerId(), md); beforeMessageIsConsumed(md); afterMessageIsConsumed(md, true); LOG.debug("{} received with excessive redelivered: {}", getConsumerId(), md); posionAck(md, "Dispatch[" + md.getRedeliveryCounter() + "] to " + getConsumerId() + " exceeds redelivery policy limit:" + redeliveryPolicy); if (timeout > 0) { timeout = Math.max(deadline - System.currentTimeMillis(), 0); } else { if (LOG.isTraceEnabled()) { LOG.trace(getConsumerId() + " received message: " + md);
void clearMessagesInProgress() { if (inProgressClearRequiredFlag.get() > 0) { synchronized (unconsumedMessages.getMutex()) { if (inProgressClearRequiredFlag.get() > 0) { LOG.debug("{} clearing unconsumed list ({}) on transport interrupt", getConsumerId(), unconsumedMessages.size()); // ensure unconsumed are rolledback up front as they may get redelivered to another consumer List<MessageDispatch> list = unconsumedMessages.removeAll(); if (!this.info.isBrowser()) { for (MessageDispatch old : list) { session.connection.rollbackDuplicate(this, old.getMessage()); } } // allow dispatch on this connection to resume session.connection.transportInterruptionProcessingComplete(); inProgressClearRequiredFlag.decrementAndGet(); // Wake up any blockers and allow them to recheck state. unconsumedMessages.getMutex().notifyAll(); } } } clearDeliveredList(); }
if (listener != null && unconsumedMessages.isRunning()) { if (redeliveryExceeded(md)) { posionAck(md, "listener dispatch[" + md.getRedeliveryCounter() + "] to " + getConsumerId() + " exceeds redelivery policy limit:" + redeliveryPolicy); return; LOG.error("{} Exception while processing message: {}", getConsumerId(), md.getMessage().getMessageId(), e); md.setRollbackCause(e); if (isAutoAcknowledgeBatch() || isAutoAcknowledgeEach() || session.isIndividualAcknowledge()) { LOG.debug("{} tracking transacted redelivery {}", getConsumerId(), md.getMessage()); if (transactedIndividualAck) { immediateIndividualTransactedAck(md); LOG.warn("{} delivering duplicate {}, pending transaction completion on {} will rollback", getConsumerId(), md.getMessage(), consumerWithPendingTransaction); session.getConnection().rollbackDuplicate(this, md.getMessage()); dispatch(md); } else { LOG.warn("{} suppressing duplicate delivery on connection, poison acking: {}", getConsumerId(), md); posionAck(md, "Suppressing duplicate delivery on connection, consumer " + getConsumerId());
private ConsumerId redeliveryPendingInCompetingTransaction(MessageDispatch md) { for (ActiveMQSession activeMQSession: session.connection.getSessions()) { for (ActiveMQMessageConsumer activeMQMessageConsumer : activeMQSession.consumers) { if (activeMQMessageConsumer.redeliveryExpectedInCurrentTransaction(md, false)) { return activeMQMessageConsumer.getConsumerId(); } } } return null; }
private ConsumerId redeliveryPendingInCompetingTransaction(MessageDispatch md) { for (ActiveMQSession activeMQSession: session.connection.getSessions()) { for (ActiveMQMessageConsumer activeMQMessageConsumer : activeMQSession.consumers) { if (activeMQMessageConsumer.redeliveryExpectedInCurrentTransaction(md, false)) { return activeMQMessageConsumer.getConsumerId(); } } } return null; }
private ConsumerId redeliveryPendingInCompetingTransaction(MessageDispatch md) { for (ActiveMQSession activeMQSession: session.connection.getSessions()) { for (ActiveMQMessageConsumer activeMQMessageConsumer : activeMQSession.consumers) { if (activeMQMessageConsumer.redeliveryExpectedInCurrentTransaction(md, false)) { return activeMQMessageConsumer.getConsumerId(); } } } return null; }
void doClose() throws JMSException { dispose(); RemoveInfo removeCommand = info.createRemoveCommand(); LOG.debug("remove: {}, lastDeliveredSequenceId: {}", getConsumerId(), lastDeliveredSequenceId); removeCommand.setLastDeliveredSequenceId(lastDeliveredSequenceId); this.session.asyncSendPacket(removeCommand); }
void doClose() throws JMSException { dispose(); RemoveInfo removeCommand = info.createRemoveCommand(); LOG.debug("remove: {}, lastDeliveredSequenceId: {}", getConsumerId(), lastDeliveredSequenceId); removeCommand.setLastDeliveredSequenceId(lastDeliveredSequenceId); this.session.asyncSendPacket(removeCommand); }