@Override public void asyncReadEntries(final int numberOfEntriesToRead, final ReadEntriesCallback callback, final Object ctx) { checkArgument(numberOfEntriesToRead > 0); if (STATE_UPDATER.get(this) == State.Closed) { callback.readEntriesFailed(new ManagedLedgerException("Cursor was already closed"), ctx); return; } PENDING_READ_OPS_UPDATER.incrementAndGet(this); OpReadEntry op = OpReadEntry.create(this, PositionImpl.get(readPosition), numberOfEntriesToRead, callback, ctx); ledger.asyncReadEntries(op); }
protected OpReadEntry newObject(Recycler.Handle<OpReadEntry> recyclerHandle) { return new OpReadEntry(recyclerHandle); } };
void asyncReadEntries(OpReadEntry opReadEntry) { final State state = STATE_UPDATER.get(this); if (state == State.Fenced || state == State.Closed) { opReadEntry.readEntriesFailed(new ManagedLedgerFencedException(), opReadEntry.ctx); return; opReadEntry.updateReadPosition(new PositionImpl(opReadEntry.readPosition.getLedgerId() + 1, 0)); opReadEntry.checkReadCompletion(); return; log.error("[{}] Error opening ledger for reading at position {} - {}", name, opReadEntry.readPosition, ex.getMessage()); opReadEntry.readEntriesFailed(ManagedLedgerException.getManagedLedgerException(ex.getCause()), opReadEntry.ctx); return null;
@Override public void readEntriesComplete(List<Entry> returnedEntries, Object ctx) { // Filter the returned entries for individual deleted messages int entriesSize = returnedEntries.size(); final PositionImpl lastPosition = (PositionImpl) returnedEntries.get(entriesSize - 1).getPosition(); if (log.isDebugEnabled()) { log.debug("[{}][{}] Read entries succeeded batch_size={} cumulative_size={} requested_count={}", cursor.ledger.getName(), cursor.getName(), returnedEntries.size(), entries.size(), count); } List<Entry> filteredEntries = cursor.filterReadEntries(returnedEntries); entries.addAll(filteredEntries); // if entries have been filtered out then try to skip reading of already deletedMessages in that range final Position nexReadPosition = entriesSize != filteredEntries.size() ? cursor.getNextAvailablePosition(lastPosition) : lastPosition.getNext(); updateReadPosition(nexReadPosition); checkReadCompletion(); }
recycle(); })); } else if (cursor.config.isAutoSkipNonRecoverableData() && exception instanceof NonRecoverableLedgerException) { callback.readEntriesFailed(exception, ctx); cursor.ledger.mbean.recordReadEntriesError(); recycle(); return; updateReadPosition(nexReadPosition); checkReadCompletion(); } else { if (!(exception instanceof TooManyRequestsException)) { recycle();
opReadEntry.updateReadPosition(new PositionImpl(nextLedgerId, 0)); } else { opReadEntry.updateReadPosition(new PositionImpl(ledger.getId() + 1, 0)); opReadEntry.checkReadCompletion(); return; long lastEntry = min(firstEntry + opReadEntry.getNumberOfEntriesToRead() - 1, lastEntryInLedger);
void checkReadCompletion() { if (entries.size() < count && cursor.hasMoreEntries()) { // We still have more entries to read from the next ledger, schedule a new async operation if (nextReadPosition.getLedgerId() != readPosition.getLedgerId()) { cursor.ledger.startReadOperationOnLedger(nextReadPosition); } // Schedule next read in a different thread cursor.ledger.getExecutor().execute(safeRun(() -> { readPosition = cursor.ledger.startReadOperationOnLedger(nextReadPosition); cursor.ledger.asyncReadEntries(OpReadEntry.this); })); } else { // The reading was already completed, release resources and trigger callback try { cursor.readOperationCompleted(); } finally { cursor.ledger.getExecutor().executeOrdered(cursor.ledger.getName(), safeRun(() -> { callback.readEntriesComplete(entries, ctx); recycle(); })); } } }
opReadEntry.updateReadPosition(new PositionImpl(nextLedgerId, 0)); } else { opReadEntry.updateReadPosition(new PositionImpl(ledger.getId() + 1, 0)); opReadEntry.checkReadCompletion(); return; long lastEntry = min(firstEntry + opReadEntry.getNumberOfEntriesToRead() - 1, lastEntryInLedger);
recycle(); })); } else if (cursor.config.isAutoSkipNonRecoverableData() && exception instanceof NonRecoverableLedgerException) { callback.readEntriesFailed(exception, ctx); cursor.ledger.mbean.recordReadEntriesError(); recycle(); return; updateReadPosition(nexReadPosition); checkReadCompletion(); } else { if (!(exception instanceof TooManyRequestsException)) { recycle();
@Override public void readEntriesComplete(List<Entry> returnedEntries, Object ctx) { // Filter the returned entries for individual deleted messages int entriesSize = returnedEntries.size(); final PositionImpl lastPosition = (PositionImpl) returnedEntries.get(entriesSize - 1).getPosition(); if (log.isDebugEnabled()) { log.debug("[{}][{}] Read entries succeeded batch_size={} cumulative_size={} requested_count={}", cursor.ledger.getName(), cursor.getName(), returnedEntries.size(), entries.size(), count); } List<Entry> filteredEntries = cursor.filterReadEntries(returnedEntries); entries.addAll(filteredEntries); // if entries have been filtered out then try to skip reading of already deletedMessages in that range final Position nexReadPosition = entriesSize != filteredEntries.size() ? cursor.getNextAvailablePosition(lastPosition) : lastPosition.getNext(); updateReadPosition(nexReadPosition); checkReadCompletion(); }
@Override public void readEntriesFailed(ManagedLedgerException status, Object ctx) { cursor.readOperationCompleted(); if (!entries.isEmpty()) { // There were already some entries that were read before, we can return them cursor.ledger.getExecutor().submit(safeRun(() -> { callback.readEntriesComplete(entries, ctx); recycle(); })); } else { if (!(status instanceof TooManyRequestsException)) { log.warn("[{}][{}] read failed from ledger at position:{} : {}", cursor.ledger.getName(), cursor.getName(), readPosition, status.getMessage()); } else { if (log.isDebugEnabled()) { log.debug("[{}][{}] read throttled failed from ledger at position:{}", cursor.ledger.getName(), cursor.getName(), readPosition); } } callback.readEntriesFailed(status, ctx); cursor.ledger.mbean.recordReadEntriesError(); recycle(); } }
void asyncReadEntries(OpReadEntry opReadEntry) { final State state = STATE_UPDATER.get(this); if (state == State.Fenced || state == State.Closed) { opReadEntry.readEntriesFailed(new ManagedLedgerFencedException(), opReadEntry.ctx); return; opReadEntry.updateReadPosition(new PositionImpl(opReadEntry.readPosition.getLedgerId() + 1, 0)); opReadEntry.checkReadCompletion(); return; log.error("[{}] Error opening ledger for reading at position {} - {}", name, opReadEntry.readPosition, ex.getMessage()); opReadEntry.readEntriesFailed(ManagedLedgerException.getManagedLedgerException(ex.getCause()), opReadEntry.ctx); return null; });
opReadEntry.updateReadPosition(new PositionImpl(nextLedgerId, 0)); opReadEntry.checkReadCompletion(); return; long lastEntry = min(firstEntry + opReadEntry.getNumberOfEntriesToRead() - 1, lastEntryInLedger);
OpReadEntry op = OpReadEntry.create(this, PositionImpl.get(readPosition), numberOfEntriesToRead, callback, ctx);
@Override public void readEntriesComplete(List<Entry> returnedEntries, Object ctx) { // Filter the returned entries for individual deleted messages int entriesSize = returnedEntries.size(); final PositionImpl lastPosition = (PositionImpl) returnedEntries.get(entriesSize - 1).getPosition(); if (log.isDebugEnabled()) { log.debug("[{}][{}] Read entries succeeded batch_size={} cumulative_size={} requested_count={}", cursor.ledger.getName(), cursor.getName(), returnedEntries.size(), entries.size(), count); } List<Entry> filteredEntries = cursor.filterReadEntries(returnedEntries); entries.addAll(filteredEntries); // if entries have been filtered out then try to skip reading of already deletedMessages in that range final Position nexReadPosition = entriesSize != filteredEntries.size() ? cursor.getNextAvailablePosition(lastPosition) : lastPosition.getNext(); updateReadPosition(nexReadPosition); checkReadCompletion(); }
void checkReadCompletion() { if (entries.size() < count && cursor.hasMoreEntries()) { // We still have more entries to read from the next ledger, schedule a new async operation if (nextReadPosition.getLedgerId() != readPosition.getLedgerId()) { cursor.ledger.startReadOperationOnLedger(nextReadPosition); } // Schedule next read in a different thread cursor.ledger.getExecutor().submit(safeRun(() -> { readPosition = cursor.ledger.startReadOperationOnLedger(nextReadPosition); cursor.ledger.asyncReadEntries(OpReadEntry.this); })); } else { // The reading was already completed, release resources and trigger callback cursor.readOperationCompleted(); cursor.ledger.getExecutor().submit(safeRun(() -> { callback.readEntriesComplete(entries, ctx); recycle(); })); } }
protected OpReadEntry newObject(Recycler.Handle<OpReadEntry> recyclerHandle) { return new OpReadEntry(recyclerHandle); } };
void asyncReadEntries(OpReadEntry opReadEntry) { final State state = STATE_UPDATER.get(this); if (state == State.Fenced || state == State.Closed) { opReadEntry.readEntriesFailed(new ManagedLedgerFencedException(), opReadEntry.ctx); return; opReadEntry.updateReadPosition(new PositionImpl(opReadEntry.readPosition.getLedgerId() + 1, 0)); opReadEntry.checkReadCompletion(); return; log.error("[{}] Error opening ledger for reading at position {} - {}", name, opReadEntry.readPosition, ex.getMessage()); opReadEntry.readEntriesFailed(new ManagedLedgerException(ex), opReadEntry.ctx); return null; });
PositionImpl readPositionRef = PositionImpl.earliest; ManagedCursorImpl cursor = new ManagedCursorImpl(bk, config, ledger, "cursor1"); OpReadEntry opReadEntry = OpReadEntry.create(cursor, readPositionRef, 1, new ReadEntriesCallback() {
void checkReadCompletion() { if (entries.size() < count && cursor.hasMoreEntries()) { // We still have more entries to read from the next ledger, schedule a new async operation if (nextReadPosition.getLedgerId() != readPosition.getLedgerId()) { cursor.ledger.startReadOperationOnLedger(nextReadPosition); } // Schedule next read in a different thread cursor.ledger.getExecutor().execute(safeRun(() -> { readPosition = cursor.ledger.startReadOperationOnLedger(nextReadPosition); cursor.ledger.asyncReadEntries(OpReadEntry.this); })); } else { // The reading was already completed, release resources and trigger callback try { cursor.readOperationCompleted(); } finally { cursor.ledger.getExecutor().executeOrdered(cursor.ledger.getName(), safeRun(() -> { callback.readEntriesComplete(entries, ctx); recycle(); })); } } }