/** * Get the name of the queue against which the report is being run. * * @return the name of the queue */ public final String getQueueName() { return _queue.getName(); }
public boolean isAutoDelete() { return _queue.getLifetimePolicy() != LifetimePolicy.PERMANENT; }
private void checkOverflow() final long maximumQueueDepthMessages = _queue.getMaximumQueueDepthMessages(); final long maximumQueueDepthBytes = _queue.getMaximumQueueDepthBytes(); do queueDepthMessages = _queue.getQueueDepthMessages(); queueDepthBytes = _queue.getQueueDepthBytes(); QueueEntry entry = _queue.getLeastSignificantOldestEntry(); _queue.deleteEntry(entry); queueDepthMessages = _queue.getQueueDepthMessages(); queueDepthBytes = _queue.getQueueDepthBytes(); break; _eventLogger.message(_queue.getLogSubject(), QueueMessages.DROPPED(counter, queueDepthBytes, queueDepthMessages,
private boolean isUnderfull() { return _destinationQueue.getOverflowPolicy() == OverflowPolicy.NONE || ((_destinationQueue.getMaximumQueueDepthBytes() < 0 || _destinationQueue.getQueueDepthBytes() + _pendingQueueDepthBytes <= _destinationQueue.getMaximumQueueDepthBytes()) && (_destinationQueue.getMaximumQueueDepthMessages() < 0 || _destinationQueue.getQueueDepthMessages() + _pendingQueueDepthMessages <= _destinationQueue.getMaximumQueueDepthMessages())); } }
public void setExclusive(boolean exclusive) { if(exclusive) { ExclusivityPolicy currentValue = _queue.getExclusive(); if(currentValue == null || currentValue == ExclusivityPolicy.NONE) { _queue.setAttribute(Queue.EXCLUSIVE, currentValue, ExclusivityPolicy.CONTAINER); } } else { ExclusivityPolicy currentValue = _queue.getExclusive(); if(currentValue != null && currentValue != ExclusivityPolicy.NONE) { _queue.setAttribute(Queue.EXCLUSIVE, currentValue, ExclusivityPolicy.NONE); } } }
@Override public boolean notifyIfNecessary(ServerMessage<?> msg, Queue<?> queue, QueueNotificationListener listener) { int msgCount; final long maximumMessageCount = queue.getAlertThresholdQueueDepthMessages(); if (maximumMessageCount!= 0 && (msgCount = queue.getQueueDepthMessages()) >= maximumMessageCount) { String notificationMsg = msgCount + ": Maximum count on queue threshold ("+ maximumMessageCount +") breached."; logNotification(this, queue, notificationMsg); listener.notifyClients(this, queue, notificationMsg); return true; } return false; } },
if (!queue.verifySessionAccess(this)) + queue.getName() + "' is exclusive, but not created on this Connection.", getChannelId()); QueueDeclareOkBody responseBody = methodRegistry.createQueueDeclareOkBody(queueName, queue.getQueueDepthMessages(), queue.getConsumerCount()); _connection.writeFrame(responseBody.generateFrame(getChannelId())); QueueDeclareOkBody responseBody = methodRegistry.createQueueDeclareOkBody(queueName, queue.getQueueDepthMessages(), queue.getConsumerCount()); _connection.writeFrame(responseBody.generateFrame(getChannelId())); if (!queue.verifySessionAccess(this)) + queue.getName() + "' is exclusive, but not created on this Connection.", getChannelId()); else if (queue.isExclusive() != exclusive) + queue.getName() + "' with different exclusivity (was: " + queue.isExclusive() + " requested " + exclusive
result.setDurable(queue.isDurable()); result.setExclusive(queue.isExclusive()); result.setAutoDelete(queue.getLifetimePolicy() != LifetimePolicy.PERMANENT); Map<String, Object> arguments = new LinkedHashMap<>(); Collection<String> availableAttrs = queue.getAvailableAttributes(); for(String attrName : availableAttrs) arguments.put(attrName, queue.getAttribute(attrName)); result.setMessageCount(queue.getQueueDepthMessages()); result.setSubscriberCount(queue.getConsumerCount());
final MessageDestination alternateBindingDestination = queue.getAlternateBindingDestination(); queue.getName(), msg.getInitialRoutingAddress()));
private void checkReject(final ServerMessage<?> newMessage) throws MessageUnacceptableException { final long maximumQueueDepthMessages = _queue.getMaximumQueueDepthMessages(); final long maximumQueueDepthBytes = _queue.getMaximumQueueDepthBytes(); final int queueDepthMessages = _queue.getQueueDepthMessages(); final long queueDepthBytes = _queue.getQueueDepthBytes(); int pendingMessages = _pendingDepthMessages.addAndGet(1); long pendingBytes = _pendingDepthBytes.addAndGet(newMessage.getSizeIncludingHeader()); boolean messagesOverflow = maximumQueueDepthMessages >= 0 && queueDepthMessages + pendingMessages > maximumQueueDepthMessages; boolean bytesOverflow = maximumQueueDepthBytes >= 0 && queueDepthBytes + pendingBytes > maximumQueueDepthBytes; if (bytesOverflow || messagesOverflow) { final long depthBytesDelta = -newMessage.getSizeIncludingHeader(); _pendingDepthBytes.addAndGet(-depthBytesDelta); _pendingDepthMessages.addAndGet(-1); final String message = String.format( "Maximum depth exceeded on '%s' : current=[count: %d, size: %d], max=[count: %d, size: %d]", _queue.getName(), queueDepthMessages + pendingMessages, queueDepthBytes + pendingBytes, maximumQueueDepthMessages, maximumQueueDepthBytes); throw new MessageUnacceptableException(message); } _pendingMessages.put(newMessage.getStoredMessage(), newMessage.getSizeIncludingHeader()); }
if (ifEmpty && !queue.isEmpty()) else if (ifUnused && !queue.isUnused()) if (!queue.verifySessionAccess(this)) + queue.getName() + "' is exclusive, but not created on this Connection.", getChannelId()); int purged = queue.deleteAndReturnCount();
/** Create an QueueLogSubject that Logs in the following format. */ public QueueLogSubject(Queue<?> queue) { setLogStringWithFormat(QUEUE_FORMAT, queue.getVirtualHost().getName(), queue.getName()); } }
private void recoverQueue(Queue<?> queue) { MessageInstanceVisitor handler = new MessageInstanceVisitor(queue); _storeReader.visitMessageInstances(queue, handler); if (handler.getNumberOfUnknownMessageInstances() > 0) { LOGGER.info("Discarded {} entry(s) associated with queue '{}' as the referenced message " + "does not exist.", handler.getNumberOfUnknownMessageInstances(), queue.getName()); } getEventLogger().message(getLogSubject(), TransactionLogMessages.RECOVERED(handler.getRecoveredCount(), queue.getName())); getEventLogger().message(getLogSubject(), TransactionLogMessages.RECOVERY_COMPLETE(queue.getName(), true)); queue.completeRecovery(); _recoveringQueues.remove(queue); if (_recoveringQueues.isEmpty() && _recoveryComplete.compareAndSet(false, true)) { completeRecovery(); } }
@Override public boolean handle(final MessageEnqueueRecord record) { long messageId = record.getMessageNumber(); String queueName = _queue.getName(); if(messageId < _maxMessageId) { ServerMessage<?> message = getRecoveredMessage(messageId); if (message != null) { LOGGER.debug("Delivering message id '{}' to queue '{}'", message.getMessageNumber(), queueName); _queue.recover(message, record); _recoveredCount++; } else { LOGGER.debug("Message id '{}' referenced in log as enqueued in queue '{}' is unknown, entry will be discarded", messageId, queueName); Transaction txn = _store.newTransaction(); txn.dequeueMessage(record); txn.commitTranAsync((Void) null); _numberOfUnknownMessageInstances++; } return _continueRecovery.get(); } else { return false; } }
public void withinTransaction(final VirtualHost.Transaction txn) { _queue.visit(new QueueEntryVisitor() { public boolean visit(final QueueEntry entry) { if(entry.acquire()) { txn.dequeue(entry); return true; } return false; } }); } });
private void checkOverfull(final long maximumQueueDepthBytes, final long maximumQueueDepthMessages) { final long queueDepthBytes = _queue.getQueueDepthBytes(); final long queueDepthMessages = _queue.getQueueDepthMessages(); if ((maximumQueueDepthBytes >= 0L && queueDepthBytes > maximumQueueDepthBytes) || (maximumQueueDepthMessages >= 0L && queueDepthMessages > maximumQueueDepthMessages)) { Subject subject = Subject.getSubject(AccessController.getContext()); Set<SessionPrincipal> sessionPrincipals = subject.getPrincipals(SessionPrincipal.class); if (!sessionPrincipals.isEmpty()) { SessionPrincipal sessionPrincipal = sessionPrincipals.iterator().next(); if (sessionPrincipal != null) { if (_overfullReported.compareAndSet(false, true)) { _eventLogger.message(_queue.getLogSubject(), QueueMessages.OVERFULL(queueDepthBytes, maximumQueueDepthBytes, queueDepthMessages, maximumQueueDepthMessages)); } final AMQPSession<?, ?> session = sessionPrincipal.getSession(); _blockedSessions.add(session); session.block(_queue); } } } }
private void flowTailToDiskIfNecessary(final long maximumQueueDepthBytes, final long maximumQueueDepthMessages) { final long queueDepthBytes = _queue.getQueueDepthBytes(); final long queueDepthMessages = _queue.getQueueDepthMessages(); if ((maximumQueueDepthBytes >= 0L && queueDepthBytes > maximumQueueDepthBytes) || (maximumQueueDepthMessages >= 0L && queueDepthMessages > maximumQueueDepthMessages)) { long cumulativeDepthBytes = 0; long cumulativeDepthMessages = 0; QueueEntryIterator queueEntryIterator = _queue.queueEntryIterator(); while (queueEntryIterator.advance()) { QueueEntry node = queueEntryIterator.getNode(); if (node != null && !node.isDeleted()) { ServerMessage message = node.getMessage(); if (message != null) { cumulativeDepthMessages++; cumulativeDepthBytes += message.getSizeIncludingHeader(); if (cumulativeDepthBytes > maximumQueueDepthBytes || cumulativeDepthMessages > maximumQueueDepthMessages) { flowToDisk(message); } } } } } }
if (existingQueue.getExclusive() == exclusivityPolicy) if (existingQueue.getConsumers().isEmpty()) existingQueue.delete();