@Override public Message getMessage() { return ref.getMessage(); }
@Override public void acknowledge(Transaction tx, ServerConsumer consumer) throws Exception { ref.acknowledge(tx, consumer); }
@Override public void updateDeliveryCount(final MessageReference ref) throws Exception { // no need to store if it's the same value // otherwise the journal will get OME in case of lots of redeliveries if (ref.getDeliveryCount() == ref.getPersistedCount()) { return; } ref.setPersistedCount(ref.getDeliveryCount()); DeliveryCountUpdateEncoding updateInfo = new DeliveryCountUpdateEncoding(ref.getQueue().getID(), ref.getDeliveryCount()); readLock(); try { messageJournal.appendUpdateRecord(ref.getMessage().getMessageID(), JournalRecordIds.UPDATE_DELIVERY_COUNT, updateInfo, syncNonTransactional, getContext(syncNonTransactional)); } finally { readUnLock(); } }
@Override public synchronized List<MessageReference> getListOnConsumer(long consumerID) { List<MessageReference> list = new LinkedList<>(); for (MessageReference ref : refsToAck) { if (ref.hasConsumerId() && ref.getConsumerId() == consumerID) { list.add(ref); } } return list; }
@Override public void afterCommit(final Transaction tx) { for (MessageReference ref : refs) { if (!ref.isAlreadyAcked()) { ref.getQueue().addTail(ref, false); } } }
@Override public void beforeRollback(final Transaction tx) throws Exception { // Reverse the ref counts, and paging sizes for (MessageReference ref : refs) { Message message = ref.getMessage(); if (message.isDurable() && ref.getQueue().isDurableMessage()) { message.decrementDurableRefCount(); } message.decrementRefCount(); } }
final Message message = ref.getMessage(); ref.handled(); ref.setConsumerId(this.id); ref.incrementDeliveryCount(); if (strictUpdateDeliveryCount && !ref.isPaged()) { if (ref.getMessage().isDurable() && ref.getQueue().isDurableMessage() && !ref.getQueue().isInternalQueue() && !ref.isPaged()) { storageManager.updateDeliveryCount(ref); ref.getQueue().acknowledge(ref, this); acks++;
@Override public void updateScheduledDeliveryTimeTransactional(final long txID, final MessageReference ref) throws Exception { ScheduledDeliveryEncoding encoding = new ScheduledDeliveryEncoding(ref.getScheduledDeliveryTime(), ref.getQueue().getID()); readLock(); try { messageJournal.appendUpdateRecordTransactional(txID, ref.getMessage().getMessageID(), JournalRecordIds.SET_SCHEDULED_DELIVERY_TIME, encoding); } finally { readUnLock(); } }
final long timeBase, final boolean ignoreRedeliveryDelay) throws Exception { Message message = reference.getMessage(); if (!internalQueue && reference.isDurable() && isDurableMessage() && !reference.isPaged()) { storageManager.updateDeliveryCount(reference); int deliveryCount = reference.getDeliveryCount(); logger.trace("Sending reference " + reference + " to DLA = " + addressSettings.getDeadLetterAddress() + " since ref.getDeliveryCount=" + reference.getDeliveryCount() + "and maxDeliveries=" + maxDeliveries + " from queue=" + this.getName()); reference.setScheduledDeliveryTime(timeBase + redeliveryDelay); if (!reference.isPaged() && reference.isDurable() && isDurableMessage()) { storageManager.updateScheduledDeliveryTime(reference);
while ((ref = deliveringRefs.poll()) != null) { if (performACK) { ref.acknowledge(tx, this); logger.trace("ServerConsumerImpl::" + this + " Preparing Cancelling list for messageID = " + ref.getMessage().getMessageID() + ", ref = " + ref);
public Map<String, Object> getFields(MessageReference ref) throws OpenDataException { Map<String, Object> rc = new HashMap<>(); ICoreMessage m = ref.getMessage().toCore(); rc.put(CompositeDataConstants.MESSAGE_ID, "" + m.getMessageID()); if (m.getUserID() != null) { rc.put(CompositeDataConstants.TIMESTAMP, new Date(m.getTimestamp())); rc.put(CompositeDataConstants.PRIORITY, m.getPriority()); rc.put(CompositeDataConstants.REDELIVERED, ref.getDeliveryCount() > 1);
ref.acknowledge(transaction, serverConsumer); Throwable poisonCause = ack.getPoisonCause(); if (poisonCause != null) { ref.getMessage().putStringProperty(OpenWireMessageConverter.AMQ_MSG_DLQ_DELIVERY_FAILURE_CAUSE_PROPERTY, new SimpleString(poisonCause.toString())); ref.getQueue().sendToDeadLetterAddress(transaction, ref); ref.getQueue().expire(ref, serverConsumer);
@Override public void deliverScheduledMessages() throws ActiveMQException { List<MessageReference> scheduledMessages = scheduledDeliveryHandler.cancel(null); if (scheduledMessages != null && scheduledMessages.size() > 0) { for (MessageReference ref : scheduledMessages) { ref.getMessage().setScheduledDeliveryTime(ref.getScheduledDeliveryTime()); ref.setScheduledDeliveryTime(0); } this.addHead(scheduledMessages, true); } }
ref.emptyConsumerID(); if (ref.isAlreadyAcked()) { ackedRefs.add(ref); Transaction ackedTX = new TransactionImpl(storageManager); for (MessageReference ref : ackedRefs) { Message message = ref.getMessage(); if (message.isDurable()) { int durableRefCount = message.incrementDurableRefCount(); storageManager.storeMessageTransactional(ackedTX.getID(), message); Queue queue = ref.getQueue();
@Override public void postAcknowledge(final MessageReference ref) { QueueImpl queue = (QueueImpl) ref.getQueue(); if (ref.isPaged()) { message = ref.getMessage(); } catch (Throwable e) { ActiveMQServerLogger.LOGGER.unableToPerformPostAcknowledge(e);
private boolean checkExpired(final MessageReference reference) { try { if (reference.getMessage().isExpired()) { if (logger.isTraceEnabled()) { logger.trace("Reference " + reference + " is expired"); } reference.handled(); try { expire(reference); } catch (Exception e) { ActiveMQServerLogger.LOGGER.errorExpiringRef(e); } return true; } else { return false; } } catch (Throwable e) { ActiveMQServerLogger.LOGGER.unableToCheckIfMessageExpired(e); return false; } }
private void debugList(boolean fail, ScheduledDeliveryHandlerImpl handler, long numberOfExpectedMessages) throws Exception { List<MessageReference> refs = handler.getScheduledReferences(); HashSet<Long> messages = new HashSet<>(); long lastTime = -1; for (MessageReference ref : refs) { assertFalse(messages.contains(ref.getMessage().getMessageID())); messages.add(ref.getMessage().getMessageID()); if (fail) { assertTrue(ref.getScheduledDeliveryTime() >= lastTime); } else { if (ref.getScheduledDeliveryTime() < lastTime) { System.out.println("^^^fail at " + ref.getScheduledDeliveryTime()); } } lastTime = ref.getScheduledDeliveryTime(); } for (long i = 0; i < numberOfExpectedMessages; i++) { assertTrue(messages.contains(Long.valueOf(i))); } }
@Override public Queue getQueue() { return ref.getQueue(); }
@Override public void acknowledge(final Transaction tx, final MessageReference ref, final AckReason reason, final ServerConsumer consumer) throws Exception { if (ref.isPaged()) { pageSubscription.ackTx(tx, (PagedReference) ref); getRefsOperation(tx).addAck(ref); } else { Message message = ref.getMessage(); boolean durableRef = message.isDurable() && isDurableMessage(); if (durableRef) { storageManager.storeAcknowledgeTransactional(tx.getID(), id, message.getMessageID()); tx.setContainsPersistent(); } getRefsOperation(tx).addAck(ref); } if (reason == AckReason.EXPIRED) { messagesExpired.incrementAndGet(); } else if (reason == AckReason.KILLED) { messagesKilled.incrementAndGet(); } else { messagesAcknowledged.incrementAndGet(); } if (server != null && server.hasBrokerMessagePlugins()) { server.callBrokerMessagePlugins(plugin -> plugin.messageAcknowledged(ref, reason, consumer)); } }