@Override public Future<Object> run(ConnectionContext ctx) throws IOException { destination.addMessage(ctx, message); return AbstractMessageStore.FUTURE; }
@Override public void recover(MessageRecoveryListener listener) throws Exception { delegate.recover(listener); }
@Override public Future<Object> run(ConnectionContext ctx) throws IOException { destination.removeMessage(ctx, ack); return AbstractMessageStore.FUTURE; } });
public void replayAddMessage(ConnectionContext context, Message message) { try { // Only add the message if it has not already been added. Message t = longTermStore.getMessage(message.getMessageId()); if (t == null) { longTermStore.addMessage(context, message); } } catch (Throwable e) { LOG.warn("Could not replay add for message '" + message.getMessageId() + "'. Message may have already been added. reason: " + e); } }
@Override public void dispose(ConnectionContext context) throws IOException { if (this.store != null) { this.store.removeAllMessages(context); this.store.dispose(context); } this.destinationStatistics.setParent(null); this.memoryUsage.stop(); this.disposed = true; }
public void replayRemoveMessage(ConnectionContext context, MessageAck messageAck) { try { // Only remove the message if it has not already been removed. Message t = longTermStore.getMessage(messageAck.getLastMessageId()); if (t != null) { longTermStore.removeMessage(context, messageAck); } } catch (Throwable e) { LOG.warn("Could not replay acknowledge for message '" + messageAck.getLastMessageId() + "'. Message may have already been acknowledged. reason: " + e); } }
ListenableFuture<Object> asyncAddQueueMessage(final TransactionStore transactionStore, ConnectionContext context, final MessageStore destination, final Message message) throws IOException { if (message.getTransactionId() != null) { getTx(message.getTransactionId()).trackStore(transactionStore); destination.addMessage(context, message); return AbstractMessageStore.FUTURE; } else { return destination.asyncAddQueueMessage(context, message); } }
ListenableFuture<Object> asyncAddTopicMessage(final TransactionStore transactionStore, ConnectionContext context, final MessageStore destination, final Message message) throws IOException { if (message.getTransactionId() != null) { getTx(message.getTransactionId()).trackStore(transactionStore); destination.addMessage(context, message); return AbstractMessageStore.FUTURE; } else { return destination.asyncAddTopicMessage(context, message); } }
@Override public void registerIndexListener(IndexListener indexListener) { getDelegate().registerIndexListener(indexListener); try { if (indexListener instanceof BaseDestination) { // update queue storeUsage Object matchingPersistenceAdapter = multiKahaDBPersistenceAdapter.destinationMap.chooseValue(getDelegate().getDestination()); if (matchingPersistenceAdapter instanceof FilteredKahaDBPersistenceAdapter) { FilteredKahaDBPersistenceAdapter filteredAdapter = (FilteredKahaDBPersistenceAdapter) matchingPersistenceAdapter; if (filteredAdapter.getUsage() != null && filteredAdapter.getPersistenceAdapter() instanceof KahaDBPersistenceAdapter) { StoreUsage storeUsage = filteredAdapter.getUsage(); storeUsage.setStore(filteredAdapter.getPersistenceAdapter()); storeUsage.setParent(multiKahaDBPersistenceAdapter.getBrokerService().getSystemUsage().getStoreUsage()); ((BaseDestination) indexListener).getSystemUsage().setStoreUsage(storeUsage); } } } } catch (Exception ignored) { LOG.warn("Failed to set mKahaDB destination store usage", ignored); } } };
messages.setUseCache(isUseCache()); messages.setMemoryUsageHighWaterMark(getCursorMemoryHighWaterMark()); store.start(); final int messageCount = store.getMessageCount(); if (messageCount > 0 && messages.isRecoveryRequired()) { BatchMessageRecoveryListener listener = new BatchMessageRecoveryListener(messageCount); do { listener.reset(); store.recoverNextMessages(getMaxPageSize(), listener); listener.processExpired(); } while (!listener.done());
Message message = iterator.next(); try { longTermStore.addMessage(context, message); } catch (Throwable e) { LOG.warn("Message could not be added to long term store: " + e.getMessage(), e); try { MessageAck ack = iterator.next(); longTermStore.removeMessage(transactionTemplate.getContext(), ack); } catch (Throwable e) { LOG.debug("Message could not be removed from long term store: " + e.getMessage(), e);
@Override public int getMessageCount() throws IOException { return delegate.getMessageCount(); }
@Override public void recoverNextMessages(int maxReturned, MessageRecoveryListener listener) throws Exception { delegate.recoverNextMessages(maxReturned, listener); }
messageId.setBrokerSequenceId(1); message.setMessageId(messageId); ms.addMessage(context, message); messageId.setBrokerSequenceId(2); message.setMessageId(messageId); ms.addMessage(context, message); ms.recover(new MessageRecoveryListener() { public boolean hasSpace() { return true;
@Override public Message getMessage(MessageId identity) throws IOException { return delegate.getMessage(identity); }
@Override public void removeAllMessages(ConnectionContext context) throws IOException { delegate.removeAllMessages(context); }
@Override public ActiveMQDestination getDestination() { return delegate.getDestination(); }
@Override public ListenableFuture<Object> asyncAddTopicMessage(ConnectionContext context, Message message) throws IOException { return delegate.asyncAddTopicMessage(context, message); }
@Override public ListenableFuture<Object> asyncAddQueueMessage(ConnectionContext context, Message message, boolean canOptimizeHint) throws IOException { return delegate.asyncAddQueueMessage(context,message,canOptimizeHint); }
public boolean recoverMessageReference(MessageId ref) throws Exception { Message message = this.store.getMessage(ref); if (message != null) { return recoverMessage(message); } else { throw new IllegalStateException("Message id " + ref + " could not be recovered from the data store for: " + store.getDestination().getQualifiedName() + " - already dispatched"); } }