@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { if (listener.hasSpace()) { Message msg = (Message) wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); } else { if (LOG.isTraceEnabled()) { LOG.trace("Message recovery limit reached for MessageRecoveryListener"); } return false; } }
@Override public void recoverNextMessages(int maxReturned, MessageRecoveryListener listener) throws Exception { synchronized (messageTable) { boolean pastLackBatch = lastBatchId == null; for (Map.Entry<MessageId, Message> entry : messageTable.entrySet()) { if (pastLackBatch) { Object msg = entry.getValue(); lastBatchId = entry.getKey(); if (msg.getClass() == MessageId.class) { listener.recoverMessageReference((MessageId) msg); } else { listener.recoverMessage((Message) msg); } } else { pastLackBatch = entry.getKey().equals(lastBatchId); } } } }
@Override public boolean recoverMessageReference(String reference) throws Exception { if (listener.hasSpace()) { listener.recoverMessageReference(new MessageId(reference)); return true; } return false; }
@Override public void recover(MessageRecoveryListener listener) throws Exception { // the message table is a synchronizedMap - so just have to synchronize here synchronized (messageTable) { for (Message message : messageTable.values()) { listener.recoverMessage(message); } } }
@Override public boolean recoverMessageReference(String reference) throws Exception { return delegate.recoverMessageReference(new MessageId(reference)); }
public boolean complete() { return !delegate.hasSpace() || recoveredCount == maxMessages; }
count++; lastBatchId = msg.getMessageId(); } else if (!listener.isDuplicate(new MessageId(msg.getMessageId()))) { if (LOG.isDebugEnabled()) { LOG.debug(destination.getQualifiedName() + " did not recover (will retry) message: " + msg.getMessageId()); } while (entry != null && count < maxReturned && listener.hasSpace());
public boolean isDuplicate(MessageId id) { return listener.isDuplicate(id); }
synchronized void recoverSubscription(MessageRecoveryListener listener) throws Exception { for (Iterator<Entry<MessageId, Message>> iter = map.entrySet().iterator(); iter.hasNext();) { Entry<MessageId, Message> entry = iter.next(); Message msg = entry.getValue(); listener.recoverMessage(msg); } }
@Override public boolean recoverMessageReference(String reference) throws Exception { if (listener.hasSpace()) { return listener.recoverMessageReference(new MessageId(reference)); } else { if (LOG.isTraceEnabled()) { LOG.trace("Message recovery limit reached for MessageRecoveryListener"); } return false; } } });
@Override public boolean recoverMessageReference(String reference) throws Exception { return listener.recoverMessageReference(new MessageId(reference)); }
public boolean complete() { return !delegate.hasSpace() || recoveredCount == maxMessages; }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { if (delegate.hasSpace() && recoveredCount < maxMessages) { Message msg = (Message) wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); lastRecovered.recovered = sequenceId; if (delegate.recoverMessage(msg)) { recoveredCount++; return true; } } return false; }
synchronized void recoverNextMessages(int maxReturned, MessageRecoveryListener listener) throws Exception { boolean pastLackBatch = lastBatch == null; MessageId lastId = null; // the message table is a synchronizedMap - so just have to synchronize here int count = 0; for (Iterator<Entry<MessageId, Message>> iter = map.entrySet().iterator(); iter.hasNext() && count < maxReturned;) { Entry<MessageId, Message> entry = iter.next(); if (pastLackBatch) { count++; Message msg = entry.getValue(); lastId = entry.getKey(); listener.recoverMessage(msg); } else { pastLackBatch = entry.getKey().equals(lastBatch); } } if (lastId != null) { lastBatch = lastId; } }
synchronized void recoverSubscription(MessageRecoveryListener listener) throws Exception { for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) { Map.Entry entry = (Entry)iter.next(); Object msg = entry.getValue(); if (msg.getClass() == MessageId.class) { listener.recoverMessageReference((MessageId)msg); } else { listener.recoverMessage((Message)msg); } } }
@Override public boolean recoverMessageReference(String reference) throws Exception { if (listener.hasSpace()) { listener.recoverMessageReference(new MessageId(reference)); return true; } return false; }
@Override public boolean recoverMessageReference(String reference) throws Exception { return listener.recoverMessageReference(new MessageId(reference)); }
public boolean complete() { return !delegate.hasSpace() || recoveredCount == maxMessages; }
protected boolean recoverMessage(MessageRecoveryListener listener, Message msg) throws Exception { listener.recoverMessage(msg); return listener.hasSpace(); }
private int recoverRolledBackAcks(int max, MessageRecoveryListener listener) throws Exception { int recovered = 0; ArrayList<Long> toRemove = new ArrayList<Long>(); synchronized (rolledBackAcks) { if (!rolledBackAcks.isEmpty()) { for ( Map.Entry<Long,Message> candidate : rolledBackAcks.entrySet()) { if (candidate.getKey() <= lastRecovered(candidate.getValue().getPriority())) { listener.recoverMessage(candidate.getValue()); recovered++; toRemove.add(candidate.getKey()); if (recovered == max) { break; } } else { toRemove.add(candidate.getKey()); } } for (Long key : toRemove) { rolledBackAcks.remove(key); } } } return recovered; }