/** * Creates a MessageAck for all messages contained in deliveredMessages. * Caller should hold the lock for deliveredMessages. * * @param type Ack-Type (i.e. MessageAck.STANDARD_ACK_TYPE) * @return <code>null</code> if nothing to ack. */ private MessageAck makeAckForAllDeliveredMessages(byte type) { synchronized (deliveredMessages) { if (deliveredMessages.isEmpty()) { return null; } MessageDispatch md = deliveredMessages.getFirst(); MessageAck ack = new MessageAck(md, type, deliveredMessages.size()); ack.setFirstMessageId(deliveredMessages.getLast().getMessage().getMessageId()); return ack; } }
/** * Write the booleans that this object uses to a BooleanStream */ public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { MessageDispatch info = (MessageDispatch)o; super.looseMarshal(wireFormat, o, dataOut); looseMarshalCachedObject(wireFormat, (DataStructure)info.getConsumerId(), dataOut); looseMarshalCachedObject(wireFormat, (DataStructure)info.getDestination(), dataOut); looseMarshalNestedObject(wireFormat, (DataStructure)info.getMessage(), dataOut); dataOut.writeInt(info.getRedeliveryCounter()); } }
/** * Un-marshal an object instance from the data input stream * * @param o the object to un-marshal * @param dataIn the data input stream to build the object from * @throws IOException */ public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException { super.tightUnmarshal(wireFormat, o, dataIn, bs); MessageDispatch info = (MessageDispatch)o; info.setConsumerId((org.apache.activemq.command.ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); info.setDestination((org.apache.activemq.command.ActiveMQDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); info.setMessage((org.apache.activemq.command.Message) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); info.setRedeliveryCounter(dataIn.readInt()); }
public MessageAck(MessageDispatch md, byte ackType, int messageCount) { this.ackType = ackType; this.consumerId = md.getConsumerId(); this.destination = md.getDestination(); this.lastMessageId = md.getMessage().getMessageId(); this.messageCount = messageCount; }
/** * @param node * @param message * @return MessageDispatch */ protected MessageDispatch createMessageDispatch(MessageReference node, Message message) { MessageDispatch md = new MessageDispatch(); md.setConsumerId(info.getConsumerId()); if (node == QueueMessageReference.NULL_MESSAGE) { md.setMessage(null); md.setDestination(null); } else { Destination regionDestination = (Destination) node.getRegionDestination(); md.setDestination(regionDestination.getActiveMQDestination()); md.setMessage(message); md.setRedeliveryCounter(node.getRedeliveryCounter()); } return md; }
MessageDispatch md = deliveredMessages.removeLast(); session.connection.rollbackDuplicate(this, md.getMessage()); MessageDispatch lastMd = deliveredMessages.getFirst(); final int currentRedeliveryCount = lastMd.getMessage().getRedeliveryCounter(); if (currentRedeliveryCount > 0) { redeliveryDelay = redeliveryPolicy.getNextRedeliveryDelay(redeliveryDelay); redeliveryDelay = redeliveryPolicy.getInitialRedeliveryDelay(); MessageId firstMsgId = deliveredMessages.getLast().getMessage().getMessageId(); for (Iterator<MessageDispatch> iter = deliveredMessages.iterator(); iter.hasNext();) { MessageDispatch md = iter.next(); md.getMessage().onMessageRolledBack(); session.connection.rollbackDuplicate(this, md.getMessage()); && lastMd.getMessage().getRedeliveryCounter() > redeliveryPolicy.getMaximumRedeliveries()) { MessageAck ack = new MessageAck(lastMd, MessageAck.POSION_ACK_TYPE, deliveredMessages.size()); ack.setFirstMessageId(firstMsgId); ack.setPoisonCause(new Throwable("Delivery[" + lastMd.getMessage().getRedeliveryCounter() + "] exceeds redelivery policy limit:" + redeliveryPolicy + ", cause:" + lastMd.getRollbackCause(), lastMd.getRollbackCause())); session.sendAck(ack,true); additionalWindowSize = Math.max(0, additionalWindowSize - deliveredMessages.size());
synchronized (deliveredMessages) { if (clearDeliveredList) { if (!deliveredMessages.isEmpty()) { if (session.isTransacted()) { previouslyDeliveredMessages = new PreviouslyDeliveredMap<MessageId, Boolean>(session.getTransactionContext().getTransactionId()); previouslyDeliveredMessages.put(delivered.getMessage().getMessageId(), false); getConsumerId(), previouslyDeliveredMessages.transactionId, deliveredMessages.size()); } else { if (session.isClientAcknowledge()) { LOG.debug("{} rolling back delivered list ({}) on transport interrupt", getConsumerId(), deliveredMessages.size()); if (!this.info.isBrowser()) { for (MessageDispatch md: deliveredMessages) { this.session.connection.rollbackDuplicate(this, md.getMessage());
private void beforeMessageIsConsumed(MessageDispatch md) throws JMSException { md.setDeliverySequenceId(session.getNextDeliveryId()); lastDeliveredSequenceId = md.getMessage().getMessageId().getBrokerSequenceId(); if (!isAutoAcknowledgeBatch()) { synchronized(deliveredMessages) { deliveredMessages.addFirst(md); } if (session.getTransacted()) { if (transactedIndividualAck) { immediateIndividualTransactedAck(md); } else { ackLater(md, MessageAck.DELIVERED_ACK_TYPE); } } } }
private void removeFromDeliveredMessages(MessageId key) { Iterator<MessageDispatch> iterator = deliveredMessages.iterator(); while (iterator.hasNext()) { MessageDispatch candidate = iterator.next(); if (key.equals(candidate.getMessage().getMessageId())) { session.connection.rollbackDuplicate(this, candidate.getMessage()); iterator.remove(); break; } } }
if (!session.getTransacted()) { deliverAcks(); if (isAutoAcknowledgeBatch()) { this.session.connection.getScheduler().cancel(optimizedAckTask); optimizedAckTask = null; if (session.isClientAcknowledge() || session.isIndividualAcknowledge()) { if (!this.info.isBrowser()) { this.session.connection.rollbackDuplicate(this, old.getMessage()); if (!session.isTransacted()) { synchronized(deliveredMessages) { deliveredMessages.clear(); this.session.removeConsumer(this); List<MessageDispatch> list = unconsumedMessages.removeAll(); if (!this.info.isBrowser()) { for (MessageDispatch old : list) { if (old.getMessage() != null) { LOG.debug("on close, rollback duplicate: {}", old.getMessage().getMessageId()); session.connection.rollbackDuplicate(this, old.getMessage());
connection.rollbackDuplicate(ActiveMQSession.this, md.getMessage()); LOG.debug("No redelivery of {} on rollback of {} due to failover of {}", md, ack.getTransactionId(), connection.getTransport()); return; if (ack.getTransactionId().isXATransaction() && !connection.hasDispatcher(ack.getConsumerId())) { LOG.debug("No local redelivery of {} on rollback of {} because consumer is no longer active on {}", md, ack.getTransactionId(), connection.getTransport()); return; RedeliveryPolicy redeliveryPolicy = connection.getRedeliveryPolicy(); int redeliveryCounter = md.getMessage().getRedeliveryCounter(); if (redeliveryPolicy.getMaximumRedeliveries() != RedeliveryPolicy.NO_MAXIMUM_REDELIVERIES && redeliveryCounter >= redeliveryPolicy.getMaximumRedeliveries()) { MessageAck ack = new MessageAck(md, MessageAck.POSION_ACK_TYPE, 1); ack.setFirstMessageId(md.getMessage().getMessageId()); ack.setPoisonCause(new Throwable("Exceeded ra redelivery policy limit:" + redeliveryPolicy)); asyncSendPacket(ack); MessageAck ack = new MessageAck(md, MessageAck.REDELIVERED_ACK_TYPE, 1); ack.setFirstMessageId(md.getMessage().getMessageId()); asyncSendPacket(ack); md.getMessage().onMessageRolledBack();
while ((messageDispatch = executor.dequeueNoWait()) != null) { final MessageDispatch md = messageDispatch; final ActiveMQMessage message = (ActiveMQMessage)md.getMessage(); earlyAck = new MessageAck(md, MessageAck.EXPIRED_ACK_TYPE, 1); earlyAck.setFirstMessageId(message.getMessageId()); } else if (connection.isDuplicate(ActiveMQSession.this, message)) { LOG.debug("{} got duplicate: {}", this, message.getMessageId()); earlyAck = new MessageAck(md, MessageAck.POSION_ACK_TYPE, 1); earlyAck.setFirstMessageId(md.getMessage().getMessageId()); earlyAck.setPoisonCause(new Throwable("Duplicate delivery to " + this)); if (isClientAcknowledge()||isIndividualAcknowledge()) { message.setAcknowledgeCallback(new Callback() { @Override md.setDeliverySequenceId(getNextDeliveryId()); lastDeliveredSequenceId = message.getMessageId().getBrokerSequenceId(); ack.setFirstMessageId(md.getMessage().getMessageId()); doStartTransaction(); ack.setTransactionId(getTransactionContext().getTransactionId()); connection.onClientInternalException(e); } finally { if (ack.getTransactionId() == null) {
protected Message configureMessage(MessageDispatch md) throws IOException { Message message = md.getMessage().copy(); // Update the packet to show where it came from. message.setBrokerPath(appendToBrokerPath(message.getBrokerPath(), localBrokerPath)); message.setProducerId(producerInfo.getProducerId()); message.setDestination(md.getDestination()); message.setMemoryUsage(null); if (message.getOriginalTransactionId() == null) { message.setOriginalTransactionId(message.getTransactionId()); } message.setTransactionId(null); if (configuration.isUseCompression()) { message.compress(); } return message; }
public void dispatch(MessageDispatch md) { // Auto ack messages when we reach 75% of the prefetch deliveredCounter++; if (deliveredCounter > (0.75 * info.getPrefetchSize())) { try { MessageAck ack = new MessageAck(md, MessageAck.STANDARD_ACK_TYPE, deliveredCounter); connection.asyncSendPacket(ack); deliveredCounter = 0; } catch (JMSException e) { connection.onClientInternalException(e); } } DataStructure o = md.getMessage().getDataStructure(); if (o != null && o.getClass() == DestinationInfo.class) { processDestinationInfo((DestinationInfo)o); } else { //This can happen across networks if (LOG.isDebugEnabled()) { LOG.debug("Unexpected message was dispatched to the AdvisoryConsumer: "+md); } } }
@Override public void preProcessDispatch(final MessageDispatch messageDispatch) { final Message message = messageDispatch.getMessage(); if (message != null) { long endTime = System.currentTimeMillis(); message.setBrokerOutTime(endTime); if (getBrokerService().isEnableStatistics()) { long totalTime = endTime - message.getBrokerInTime(); ((Destination) message.getRegionDestination()).getDestinationStatistics().getProcessTime().addTime(totalTime); if (((BaseDestination) message.getRegionDestination()).isPersistJMSRedelivered() && !message.isRedelivered()) { ((BaseDestination) message.getRegionDestination()).getMessageStore().updateMessage(message); messageDispatch.setTransmitCallback(new TransmitCallback() { final TransmitCallback delegate = messageDispatch.getTransmitCallback(); @Override public void onSuccess() {
m = ((MessageDispatch)bc).getMessage(); sb.append(m.getMessageId()); sb.append(','); sb.append(m.getCommandId()); ProducerId pid = m.getProducerId(); long sid = pid.getSessionId(); sb.append(','); sb.append(((MessageDispatch)bc).getConsumerId()); MessageAck ma = (MessageAck)bc; sb.append(" ConsumerID:"); sb.append(ma.getConsumerId()); sb.append(" ack:"); sb.append(ma.getFirstMessageId()); sb.append('-'); sb.append(ma.getLastMessageId());
networkBridgeStatistics.getEnqueues().increment(); final MessageDispatch md = (MessageDispatch) command; final DemandSubscription sub = subscriptionMapByLocalId.get(md.getConsumerId()); if (sub != null && md.getMessage() != null && sub.incrementOutstandingResponses()) { configuration.getBrokerName(), remoteBrokerName, Arrays.toString(md.getMessage().getBrokerPath()), md.getMessage() }); localBroker.oneway(new MessageAck(md, MessageAck.INDIVIDUAL_ACK_TYPE, 1)); } finally { sub.decrementOutstandingResponses(); configuration.getBrokerName(), remoteBrokerName, md.getConsumerId(), message.getDestination(), Arrays.toString(message.getBrokerPath()), (LOG.isTraceEnabled() ? message : message.getMessageId()) }); if (isDuplex() && NetworkBridgeFilter.isAdvisoryInterpretedByNetworkBridge(message)) { if (isPermissableDestination(md.getDestination())) { if (message.isPersistent() || configuration.isAlwaysSyncSend()) { localBroker.oneway(new MessageAck(md, MessageAck.INDIVIDUAL_ACK_TYPE, 1)); networkBridgeStatistics.getDequeues().increment(); } finally { LOG.debug("No subscription registered with this network bridge for consumerId: {} for message: {}", md.getConsumerId(), md.getMessage());
synchronized (unconsumedMessages.getMutex()) { if (!unconsumedMessages.isClosed()) { if (this.info.isBrowser() || !session.connection.isDuplicate(this, md.getMessage())) { 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()) { if (!unconsumedMessages.isRunning()) { session.connection.rollbackDuplicate(this, md.getMessage()); if (md.getMessage() == null) { LOG.debug("{} tracking transacted redelivery {}", getConsumerId(), md.getMessage()); if (transactedIndividualAck) { immediateIndividualTransactedAck(md); } else { session.sendAck(new MessageAck(md, MessageAck.DELIVERED_ACK_TYPE, 1)); LOG.warn("{} delivering duplicate {}, pending transaction completion on {} will rollback", getConsumerId(), md.getMessage(), consumerWithPendingTransaction); session.getConnection().rollbackDuplicate(this, md.getMessage()); dispatch(md); } else {
@Override public Response processMessageDispatch(MessageDispatch md) throws Exception { waitForTransportInterruptionProcessingToComplete(); ActiveMQDispatcher dispatcher = dispatchers.get(md.getConsumerId()); if (dispatcher != null) { // Copy in case a embedded broker is dispatching via // vm:// // md.getMessage() == null to signal end of queue // browse. Message msg = md.getMessage(); if (msg != null) { msg = msg.copy(); msg.setReadOnlyBody(true); msg.setReadOnlyProperties(true); msg.setRedeliveryCounter(md.getRedeliveryCounter()); msg.setConnection(ActiveMQConnection.this); msg.setMemoryUsage(null); md.setMessage(msg); } dispatcher.dispatch(md); } else { LOG.debug("{} no dispatcher for {} in {}", this, md, dispatchers); } return null; }
Message message = md.getMessage(); message.setProducerId(producerInfo.getProducerId()); if (message.getOriginalTransactionId() == null) { message.setOriginalTransactionId(message.getTransactionId()); message.setTransactionId(null); localBroker.oneway(new MessageAck(md, MessageAck.STANDARD_ACK_TYPE, 1)); } else { dequeueCounter.incrementAndGet(); localBroker.oneway(new MessageAck(md, MessageAck.STANDARD_ACK_TYPE, 1));