@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 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); } } } }
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); } }
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; } }
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; }
protected int recoverRolledBackAcks(StoredDestination sd, Transaction tx, int maxReturned, MessageRecoveryListener listener) throws Exception { int counter = 0; String id; for (Iterator<String> iterator = rolledBackAcks.iterator(); iterator.hasNext(); ) { id = iterator.next(); iterator.remove(); Long sequence = sd.messageIdIndex.get(tx, id); if (sequence != null) { if (sd.orderIndex.alreadyDispatched(sequence)) { listener.recoverMessage(loadMessage(sd.orderIndex.get(tx, sequence).location)); counter++; if (counter >= maxReturned) { break; } } else { LOG.info("rolledback ack message {} with seq {} will be picked up in future batch {}", id, sequence, sd.orderIndex.cursor); } } else { LOG.warn("Failed to locate rolled back ack message {} in {}", id, sd); } } return counter; }
@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 boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); }
@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; }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); msg.getMessageId().setFutureOrSequenceLong(sequenceId); msg.getMessageId().setEntryLocator(sequenceId); listener.recoverMessage(msg); trackLastRecovered(sequenceId, msg.getPriority()); return true; }
@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 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); } } }
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); } }
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); } }
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); } }
public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); return listener.recoverMessage(msg); }
@Override public boolean recoverMessage(long sequenceId, byte[] data) throws Exception { Message msg = (Message)wireFormat.unmarshal(new ByteSequence(data)); msg.getMessageId().setBrokerSequenceId(sequenceId); msg.getMessageId().setFutureOrSequenceLong(sequenceId); listener.recoverMessage(msg); trackLastRecovered(sequenceId, msg.getPriority()); return true; }