void read() { lh.asyncReadEntries(entryId, entryId, this, null); }
/** * Async Read Entries * * @param ledgerDesc * ledger descriptor * @param first * first entry * @param last * second entry */ public Future<Enumeration<LedgerEntry>> asyncReadEntries( LedgerDescriptor ledgerDesc, long first, long last) { RefCountedLedgerHandle refHandle = handlesMap.get(ledgerDesc); if (null == refHandle) { LOG.error("Accessing ledger {} without opening.", ledgerDesc); return Future.exception(BKException.create(BKException.Code.UnexpectedConditionException)); } final Promise<Enumeration<LedgerEntry>> promise = new Promise<Enumeration<LedgerEntry>>(); refHandle.handle.asyncReadEntries(first, last, new AsyncCallback.ReadCallback() { @Override public void readComplete(int rc, LedgerHandle lh, Enumeration<LedgerEntry> entries, Object ctx) { if (BKException.Code.OK == rc) { promise.setValue(entries); } else { promise.setException(BKException.create(rc)); } } }, null); return promise; }
if (rc == BKException.Code.OK) { long lastEntry = lh.getLastAddConfirmed(); lh.asyncReadEntries(lastEntry, lastEntry, (rc1, lh1, seq, ctx1) -> { try { LedgerEntry entry = seq.nextElement();
lh.asyncReadEntries(lastEntryInLedger, lastEntryInLedger, (rc1, lh1, seq, ctx1) -> { if (log.isDebugEnabled()) { log.debug("[{}} readComplete rc={} entryId={}", ledger.getName(), rc1, lh1.getLastAddConfirmed());
@Override public void asyncReadEntry(LedgerHandle lh, long firstEntry, long lastEntry, boolean isSlowestReader, final ReadEntriesCallback callback, Object ctx) { lh.asyncReadEntries(firstEntry, lastEntry, new ReadCallback() { public void readComplete(int rc, LedgerHandle lh, Enumeration<LedgerEntry> seq, Object bkctx) { if (rc != BKException.Code.OK) { callback.readEntriesFailed(new ManagedLedgerException(BKException.create(rc)), ctx); return; } List<Entry> entries = Lists.newArrayList(); long totalSize = 0; while (seq.hasMoreElements()) { // Insert the entries at the end of the list (they will be unsorted for now) LedgerEntry ledgerEntry = seq.nextElement(); EntryImpl entry = EntryImpl.create(ledgerEntry); ledgerEntry.getEntryBuffer().release(); entries.add(entry); totalSize += entry.getLength(); } mlFactoryMBean.recordCacheMiss(entries.size(), totalSize); ml.mbean.addReadEntriesSample(entries.size(), totalSize); callback.readEntriesComplete(entries, null); } }, null); }
@Override public CompletableFuture<List<Entry.Reader>> readEntries(long startEntryId, long endEntryId) { CompletableFuture<List<Entry.Reader>> promise = new CompletableFuture<List<Entry.Reader>>(); lh.asyncReadEntries(startEntryId, endEntryId, this, promise); return promise; }
private void issueSimpleRead(CacheEntry cacheEntry) { getLh().asyncReadEntries(cacheEntry.entryId, cacheEntry.entryId, cacheEntry, null); }
static CompletableFuture<LedgerEntry> getLedgerEntry(LedgerHandle ledger, long entry) { final CompletableFuture<LedgerEntry> future = new CompletableFuture<>(); ledger.asyncReadEntries(entry, entry, (rc, handle, entries, ctx) -> { if (rc != BKException.Code.OK) { future.completeExceptionally(bkException("Failed to read entry", rc, ledger.getId(), entry)); } else { future.complete(entries.nextElement()); } }, null ); return future; }
lh.asyncReadEntries(entryId, entryId, new ReadCallback() { @Override public void readComplete(int rc, LedgerHandle lh,
/** * Read a sequence of entries synchronously. * * @param firstEntry * id of first entry of sequence (included) * @param lastEntry * id of last entry of sequence (included) * * @see #asyncReadEntries(long, long, ReadCallback, Object) */ public Enumeration<LedgerEntry> readEntries(long firstEntry, long lastEntry) throws InterruptedException, BKException { CompletableFuture<Enumeration<LedgerEntry>> result = new CompletableFuture<>(); asyncReadEntries(firstEntry, lastEntry, new SyncReadCallback(result), null); return SyncCallbackUtils.waitForResult(result); }
@Override public void readEntries( long ledgerID, long firstEntryID, long lastEntryID, BiConsumer<Integer, ArrayList<byte[]>> cb) { client.asyncOpenLedgerNoRecovery(ledgerID, BookKeeper.DigestType.CRC32, new byte[0], (rc, lh, ctx) -> { if (rc != 0) { cb.accept(rc, null); return; } System.out.format("Got handle for read %d -> %d on ledger %d%n", firstEntryID, lastEntryID, ledgerID); lh.asyncReadEntries(firstEntryID, lastEntryID, (rc1, lh1, seq, ctx1) -> { System.out.format("Read cb %d -> %d on ledger %d%n", firstEntryID, lastEntryID, ledgerID); ArrayList<byte[]> results = new ArrayList<>(); if (rc1 == 0) { while (seq.hasMoreElements()) { results.add(seq.nextElement().getEntry()); } System.out.format("About to close handle for read %d -> %d on ledger %d%n", firstEntryID, lastEntryID, ledgerID); } lh.asyncClose((rc2, lh2, ctx2) -> { System.out.format("Closed handle for read %d -> %d on ledger %d result %d%n", firstEntryID, lastEntryID, ledgerID, rc2); cb.accept(rc1 == 0 ? rc2 : rc1, results); }, null); }, null); }, null); } }
public LedgerEntry readLastEntry() throws InterruptedException, BKException { long lastEntryId = getLastAddConfirmed(); if (lastEntryId < 0) { // Ledger was empty, so there is no last entry to read throw new BKException.BKNoSuchEntryException(); } else { CompletableFuture<Enumeration<LedgerEntry>> result = new CompletableFuture<>(); asyncReadEntries(lastEntryId, lastEntryId, new SyncReadCallback(result), null); return SyncCallbackUtils.waitForResult(result).nextElement(); } }
private static CompletableFuture<MessageIdData> readOneMessageId(LedgerHandle lh, long entryId) { CompletableFuture<MessageIdData> promise = new CompletableFuture<>(); lh.asyncReadEntries(entryId, entryId, (rc, _lh, seq, ctx) -> { if (rc != BKException.Code.OK) { promise.completeExceptionally(BKException.create(rc)); } else { try (RawMessage m = RawMessageImpl.deserializeFrom( seq.nextElement().getEntryBuffer())) { promise.complete(m.getMessageIdData()); } catch (NoSuchElementException e) { log.error("No such entry {} in ledger {}", entryId, lh.getId()); promise.completeExceptionally(e); } } }, null); return promise; }
private static CompletableFuture<List<Entry>> readEntries(LedgerHandle lh, long from, long to) { CompletableFuture<Enumeration<LedgerEntry>> promise = new CompletableFuture<>(); lh.asyncReadEntries(from, to, (rc, _lh, seq, ctx) -> { if (rc != BKException.Code.OK) { promise.completeExceptionally(BKException.create(rc)); } else { promise.complete(seq); } }, null); return promise.thenApply( (seq) -> { List<Entry> entries = new ArrayList<Entry>(); while (seq.hasMoreElements()) { ByteBuf buf = seq.nextElement().getEntryBuffer(); try (RawMessage m = RawMessageImpl.deserializeFrom(buf)) { entries.add(EntryImpl.create(m.getMessageIdData().getLedgerId(), m.getMessageIdData().getEntryId(), m.getHeadersAndPayload())); } finally { buf.release(); } } return entries; }); }
lh.asyncReadEntries(firstEntry, lastEntry, (rc, lh1, sequence, cb) -> {
asyncReadEntries(entryId, entryId, new ReadCallback() { @Override public void readComplete(int rc, LedgerHandle lh, Enumeration<LedgerEntry> seq, Object ctx) {
lh.asyncReadEntries(lastEntryInLedger, lastEntryInLedger, (rc1, lh1, seq, ctx1) -> { if (log.isDebugEnabled()) { log.debug("[{}} readComplete rc={} entryId={}", ledger.getName(), rc1, lh1.getLastAddConfirmed());
callback.readEntryComplete(cachedEntry, ctx); } else { lh.asyncReadEntries(position.getEntryId(), position.getEntryId(), (rc, ledgerHandle, sequence, obj) -> { if (rc != BKException.Code.OK) { ml.invalidateLedgerHandle(ledgerHandle, rc);