@Override public void restoreCredit(final QueueEntry queueEntry) { _target.restoreCredit(queueEntry.getMessage()); }
@Override public void move(final QueueEntry entry, final Queue<?> queue) final ServerMessage message = entry.getMessage(); if(entry.acquire()) txn.dequeue(entry.getEnqueueRecord(), new ServerTransaction.Action()
private void routeToAlternate(QueueEntry entry, Runnable postRouteTask, Predicate<BaseQueue> predicate) { boolean acquiredForDequeueing = entry.acquireOrSteal(() -> { LOGGER.debug("routing stolen node {} to alternate", entry); entry.routeToAlternate(null, null, predicate); if (postRouteTask != null) { postRouteTask.run(); } }); if (acquiredForDequeueing) { LOGGER.debug("routing node {} to alternate", entry); entry.routeToAlternate(null, null, predicate); if (postRouteTask != null) { postRouteTask.run(); } } }
private void updateExpiration(final QueueEntry entry) { long expiration = calculateExpiration(entry.getMessage()); if (expiration > 0) { entry.setExpiration(expiration); } }
void scavenge() { QueueEntry hwm = _unscavengedHWM.getAndSet(null); QueueEntry next = _head.getNextValidEntry(); if(hwm != null) { while (next != null && hwm.compareTo(next)>0) { next = next.getNextValidEntry(); } } }
if (entry.isRejectedBy(this) || entry.checkHeld(System.currentTimeMillis())) if (entry.getMessage().getClass() == _messageClass) Object connectionRef = entry.getMessage().getConnectionReference(); if (connectionRef != null && connectionRef == _sessionReference) if(_messageClass != null && MessageConverterRegistry.getConverter(entry.getMessage().getClass(), _messageClass)==null) MessageReference ref = entry.newMessageReference(); if(ref != null) Filterable msg = entry.asFilterable(); try
if (!node.isDeleted()) ServerMessage msg = node.getMessage(); if (msg != null) if (node.expired())
if (!node.isDeleted()) if (node.expired()) node.checkHeld(currentTime); ServerMessage msg = node.getMessage(); if (msg != null)
void updateStatsOnEnqueue(QueueEntry entry) { final long sizeWithHeader = entry.getSizeWithHeader(); final QueueStatistics queueStatistics = _queueStatistics; queueStatistics.addToAvailable(sizeWithHeader); queueStatistics.addToQueue(sizeWithHeader); queueStatistics.addToEnqueued(sizeWithHeader); if(_forcePersistent || (_respectPersistent && entry.getMessage().isPersistent())) { queueStatistics.addToPersistentEnqueued(sizeWithHeader); } }
@Override public QueueEntry getOldestEntry() { QueueEntry oldestEntry = null; QueueEntryIterator iter = iterator(); while (iter.advance()) { QueueEntry node = iter.getNode(); if (node != null && !node.isDeleted()) { ServerMessage msg = node.getMessage(); if(msg != null && (oldestEntry == null || oldestEntry.getMessage().getMessageNumber() > msg.getMessageNumber())) { oldestEntry = node; } } } return oldestEntry; }
for (QueueEntry queueEntry : messages) ServerMessage serverMsg = queueEntry.getMessage(); AMQMessageHeader header = serverMsg.getMessageHeader(); String[] headerAttributes = headerAttributes, serverMsg.getSize(), queueEntry.isRedelivered(), position, queueEntry.getDeliveryCount()};
@Override public boolean visit(final QueueEntry entry) { final ServerMessage message = entry.getMessage(); boolean stop = false; if (message != null) { final long messageId = message.getMessageNumber(); if ((_messageIds == null || _messageIds.remove(messageId)) && (_filter == null || _filter.matches(entry.asFilterable()))) { stop = updateEntry(entry, txn); _modifiedMessageIds.add(messageId); if (_limit > 0) { _limit--; } } } return stop || _limit == 0 || (_messageIds != null && _messageIds.isEmpty()); } });
protected void doEnqueue(final ServerMessage message, final Action<? super MessageInstance> action, MessageEnqueueRecord enqueueRecord) { final QueueEntry entry = getEntries().add(message, enqueueRecord); updateExpiration(entry); try { if (entry.isAvailable()) { checkConsumersNotAheadOfDelivery(entry); notifyConsumers(entry); } checkForNotificationOnNewMessage(entry.getMessage()); } finally { if(action != null) { action.performAction(entry); } RejectPolicyHandler rejectPolicyHandler = _rejectPolicyHandler; if (rejectPolicyHandler != null) { rejectPolicyHandler.postEnqueue(entry); } _postEnqueueOverflowPolicyHandler.checkOverflow(entry); } }
private void discardEntry(final QueueEntry entry) { if(entry.acquire()) { ServerTransaction txn = new AutoCommitTransaction(getQueue().getVirtualHost().getMessageStore()); txn.dequeue(entry.getEnqueueRecord(), new ServerTransaction.Action() { @Override public void postCommit() { entry.delete(); } @Override public void onRollback() { } }); } }
QueueEntry releasedNode = context.getReleasedEntry(); QueueEntry node = (releasedNode != null && lastSeen.compareTo(releasedNode)>=0) ? releasedNode : getEntries() .next(lastSeen); while (node != null && (!node.isAvailable() || (expired = node.expired()) || !sub.hasInterest(node) || !mightAssign(sub,node))) node = (releasedNode != null && lastSeen.compareTo(releasedNode)>=0) ? releasedNode : getEntries().next(lastSeen);
@Override public void dequeue(final QueueEntry messageInstance) { final ServerTransaction.Action deleteAction = new ServerTransaction.Action() { @Override public void postCommit() { messageInstance.delete(); } @Override public void onRollback() { } }; boolean acquired = messageInstance.acquireOrSteal(new Runnable() { @Override public void run() { ServerTransaction txn = new AutoCommitTransaction(store); txn.dequeue(messageInstance.getEnqueueRecord(), deleteAction); } }); if(acquired) { txn.dequeue(messageInstance.getEnqueueRecord(), deleteAction); } }
@Override protected void checkConsumersNotAheadOfDelivery(final QueueEntry entry) { // check that all consumers are not in advance of the entry Iterator<QueueConsumer<?,?>> consumerIterator = getQueueConsumerManager().getAllIterator(); while (consumerIterator.hasNext() && !entry.isAcquired()) { QueueConsumer<?,?> consumer = consumerIterator.next(); if(!consumer.isClosed()) { QueueContext context = consumer.getQueueContext(); if(context != null) { QueueEntry released = context.getReleasedEntry(); while(!entry.isAcquired() && (released == null || released.compareTo(entry) > 0)) { if(QueueContext._releasedUpdater.compareAndSet(context,released,entry)) { break; } else { released = context.getReleasedEntry(); } } } } } }
@Override public void postCommit() { entry.delete(); }
@Override public boolean accept(QueueEntry entry) { return entry.acquire(); }
@Override public void entryDeleted(QueueEntry queueEntry) { QueueEntry next = _head.getNextNode(); QueueEntry newNext = _head.getNextValidEntry(); // the head of the queue has not been deleted, hence the deletion must have been mid queue. if (next == newNext) { QueueEntry unscavengedHWM = _unscavengedHWM.get(); while(unscavengedHWM == null || unscavengedHWM.compareTo(queueEntry)<0) { _unscavengedHWM.compareAndSet(unscavengedHWM, queueEntry); unscavengedHWM = _unscavengedHWM.get(); } if (_scavenges.incrementAndGet() > _scavengeCount) { _scavenges.set(0L); scavenge(); } } else { QueueEntry unscavengedHWM = _unscavengedHWM.get(); if(unscavengedHWM != null && (next == null || unscavengedHWM.compareTo(next) < 0)) { _unscavengedHWM.compareAndSet(unscavengedHWM, null); } } }