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); } } }
/** * Write the booleans that this object uses to a BooleanStream */ public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { MessageAck info = (MessageAck)o; super.looseMarshal(wireFormat, o, dataOut); looseMarshalCachedObject(wireFormat, (DataStructure)info.getDestination(), dataOut); looseMarshalCachedObject(wireFormat, (DataStructure)info.getTransactionId(), dataOut); looseMarshalCachedObject(wireFormat, (DataStructure)info.getConsumerId(), dataOut); dataOut.writeByte(info.getAckType()); looseMarshalNestedObject(wireFormat, (DataStructure)info.getFirstMessageId(), dataOut); looseMarshalNestedObject(wireFormat, (DataStructure)info.getLastMessageId(), dataOut); dataOut.writeInt(info.getMessageCount()); } }
/** * 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); MessageAck info = (MessageAck)o; info.setDestination((org.apache.activemq.command.ActiveMQDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); info.setTransactionId((org.apache.activemq.command.TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); info.setConsumerId((org.apache.activemq.command.ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); info.setAckType(dataIn.readByte()); info.setFirstMessageId((org.apache.activemq.command.MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); info.setLastMessageId((org.apache.activemq.command.MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); info.setMessageCount(dataIn.readInt()); }
/** * A helper method to allow a single message ID to be acknowledged */ public void setMessageID(MessageId messageID) { setFirstMessageId(messageID); setLastMessageId(messageID); setMessageCount(1); }
void acknowledge(MessageDispatch md, byte ackType) throws JMSException { MessageAck ack = new MessageAck(md, ackType, 1); if (ack.isExpiredAck()) { ack.setFirstMessageId(ack.getLastMessageId()); } session.sendAck(ack); synchronized(deliveredMessages){ deliveredMessages.remove(md); } }
private void posionAck(MessageDispatch md, String cause) throws JMSException { MessageAck posionAck = new MessageAck(md, MessageAck.POSION_ACK_TYPE, 1); posionAck.setFirstMessageId(md.getMessage().getMessageId()); posionAck.setPoisonCause(new Throwable(cause)); session.sendAck(posionAck); }
/** * Write the booleans that this object uses to a BooleanStream */ public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { MessageAck info = (MessageAck)o; int rc = super.tightMarshal1(wireFormat, o, bs); rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getDestination(), bs); rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getTransactionId(), bs); rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getConsumerId(), bs); rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getFirstMessageId(), bs); rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getLastMessageId(), bs); rc += tightMarshalThrowable1(wireFormat, info.getPoisonCause(), bs); return rc + 5; }
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)); md.setDeliverySequenceId(getNextDeliveryId()); lastDeliveredSequenceId = message.getMessageId().getBrokerSequenceId(); final MessageAck ack = new MessageAck(md, MessageAck.STANDARD_ACK_TYPE, 1); ack.setFirstMessageId(md.getMessage().getMessageId()); doStartTransaction(); ack.setTransactionId(getTransactionContext().getTransactionId()); if (ack.getTransactionId() != null) { connection.onClientInternalException(e); } finally { if (ack.getTransactionId() == null) {
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);
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 (info.getCurrentPrefetchSize() == 0) { unconsumedMessages.enqueue(null); 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 {
public void remove(SubscriptionView view, String messageId) throws Exception { ActiveMQDestination destination = getTopicDestination(view); if (destination != null) { final Destination topic = getTopicRegion().getDestinationMap().get(destination); final MessageAck messageAck = new MessageAck(); messageAck.setMessageID(new MessageId(messageId)); messageAck.setDestination(destination); topic.getMessageStore().removeMessage(brokerService.getAdminConnectionContext(), messageAck); // if sub is active, remove from cursor if (view.subscription instanceof DurableTopicSubscription) { final DurableTopicSubscription durableTopicSubscription = (DurableTopicSubscription) view.subscription; final MessageReference messageReference = new NullMessageReference(); messageReference.getMessage().setMessageId(messageAck.getFirstMessageId()); durableTopicSubscription.getPending().remove(messageReference); } } else { throw new IllegalStateException("can't determine topic for sub:" + view); } }
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());
if (!this.info.isBrowser()) { synchronized(deliveredMessages) { for (int i = 0; (i < deliveredMessages.size()) && (i < ackCounter); i++) { session.connection.rollbackDuplicate(this, md.getMessage()); final int currentRedeliveryCount = lastMd.getMessage().getRedeliveryCounter(); if (currentRedeliveryCount > 0) { redeliveryDelay = redeliveryPolicy.getNextRedeliveryDelay(redeliveryDelay); redeliveryDelay = redeliveryPolicy.getInitialRedeliveryDelay(); MessageId firstMsgId = deliveredMessages.getLast().getMessage().getMessageId(); md.getMessage().onMessageRolledBack(); session.connection.rollbackDuplicate(this, md.getMessage()); 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); MessageAck ack = new MessageAck(lastMd, MessageAck.REDELIVERED_ACK_TYPE, deliveredMessages.size()); ack.setFirstMessageId(firstMsgId); session.sendAck(ack,true);
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)) { localBroker.oneway(new MessageAck(md, MessageAck.INDIVIDUAL_ACK_TYPE, 1)); networkBridgeStatistics.getDequeues().increment(); } finally {
public void setDestination(ActiveMQDestination destination) { if (command.isMessage()) { Message message = (Message) command; if (message.getOriginalDestination() == null) { message.setOriginalDestination(message.getDestination()); } message.setDestination(destination); } if (command.isMessageDispatch()) { MessageDispatch messageDispatch = (MessageDispatch) command; Message message = messageDispatch.getMessage(); if (message.getOriginalDestination() == null) { message.setOriginalDestination(message.getDestination()); } message.setDestination(destination); messageDispatch.setDestination(destination); } if (command.isMessageAck()) { ((MessageAck) command).setDestination(destination); } if (command instanceof ConsumerInfo) { ((ConsumerInfo) command).setDestination(destination); } }
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));
@Override public void afterRollback() throws Exception { md.getMessage().onMessageRolledBack(); connection.rollbackDuplicate(ActiveMQSession.this, md.getMessage()); 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()); asyncSendPacket(ack); } else { MessageAck ack = new MessageAck(md, MessageAck.REDELIVERED_ACK_TYPE, 1); ack.setFirstMessageId(md.getMessage().getMessageId()); asyncSendPacket(ack);
protected MessageAck convertToNonRangedAck(MessageAck ack, MessageReference node) { // the original ack may be a ranged ack, but we are trying to delete // a specific // message store here so we need to convert to a non ranged ack. if (ack.getMessageCount() > 0) { // Dup the ack MessageAck a = new MessageAck(); ack.copy(a); ack = a; // Convert to non-ranged. ack.setMessageCount(1); } // always use node messageId so we can access entry/data Location ack.setFirstMessageId(node.getMessageId()); ack.setLastMessageId(node.getMessageId()); return ack; }
public void recoverAck(long id, byte[] xid, byte[] message) throws IOException { final Message msg = (Message) ((JDBCPersistenceAdapter)persistenceAdapter).getWireFormat().unmarshal(new ByteSequence(message)); msg.getMessageId().setFutureOrSequenceLong(id); msg.getMessageId().setEntryLocator(id); Tx tx = getPreparedTx(new XATransactionId(xid)); final MessageAck ack = new MessageAck(msg, MessageAck.STANDARD_ACK_TYPE, 1); tx.add(new RecoveredRemoveMessageCommand() { MessageStore messageStore = null; @Override public MessageAck getMessageAck() { return ack; } @Override public void run(ConnectionContext context) throws IOException { ((JDBCPersistenceAdapter)persistenceAdapter).commitRemove(context, ack); } public Message getMessage() { return msg; } @Override public void setMessageStore(MessageStore messageStore) { this.messageStore = messageStore; } @Override public MessageStore getMessageStore() { return messageStore; } }); }
safeWaitUntilStarted(); MessageDispatch md = (MessageDispatch) command; serviceRemoteConsumerAdvisory(md.getMessage().getDataStructure()); ackAdvisory(md.getMessage()); } else if (command.isBrokerInfo()) { futureRemoteBrokerInfo.set((BrokerInfo) command); case MessageAck.DATA_STRUCTURE_TYPE: MessageAck ack = (MessageAck) command; DemandSubscription localSub = subscriptionMapByRemoteId.get(ack.getConsumerId()); if (localSub != null) { ack.setConsumerId(localSub.getLocalInfo().getConsumerId()); localBroker.oneway(ack); } else {