@Override public CompletableFuture<LedgerEntries> readAsync(long firstEntry, long lastEntry) { return readHandle.readAsync(firstEntry, lastEntry); }
@Override public CompletableFuture<LastConfirmedAndEntry> readLastAddConfirmedAndEntryAsync(long entryId, long timeOutInMillis, boolean parallel) { return readHandle.readLastAddConfirmedAndEntryAsync(entryId, timeOutInMillis, parallel); }
@Override public long getLength() { return metadata.getLength(); }
MockMetadata(LedgerMetadata toCopy) { ensembleSize = toCopy.getEnsembleSize(); writeQuorumSize = toCopy.getWriteQuorumSize(); ackQuorumSize = toCopy.getAckQuorumSize(); lastEntryId = toCopy.getLastEntryId(); length = toCopy.getLength(); digestType = toCopy.getDigestType(); ctime = toCopy.getCtime(); isClosed = toCopy.isClosed(); customMetadata = ImmutableMap.copyOf(toCopy.getCustomMetadata()); }
private static ReadHandle getLedgerHandle() { final ReadHandle lh = mock(ReadHandle.class); final LedgerEntry ledgerEntry = mock(LedgerEntry.class, Mockito.CALLS_REAL_METHODS); doReturn(Unpooled.wrappedBuffer(new byte[10])).when(ledgerEntry).getEntryBuffer(); doReturn((long) 10).when(ledgerEntry).getLength(); doAnswer((invocation) -> { Object[] args = invocation.getArguments(); long firstEntry = (Long) args[0]; long lastEntry = (Long) args[1]; Vector<LedgerEntry> entries = new Vector<LedgerEntry>(); for (int i = 0; i <= (lastEntry - firstEntry); i++) { entries.add(ledgerEntry); } LedgerEntries ledgerEntries = mock(LedgerEntries.class); doAnswer((invocation2) -> entries.iterator()).when(ledgerEntries).iterator(); return CompletableFuture.completedFuture(ledgerEntries); }).when(lh).readAsync(anyLong(), anyLong()); return lh; }
MockOffloadReadHandle(ReadHandle toCopy) throws Exception { id = toCopy.getId(); long lac = toCopy.getLastAddConfirmed(); try (LedgerEntries entries = toCopy.read(0, lac)) { for (LedgerEntry e : entries) { this.entries.add(e.getEntryBuffer().retainedSlice()); } } metadata = new MockMetadata(toCopy.getLedgerMetadata()); }
public static EntryImpl create(LedgerEntry ledgerEntry) { EntryImpl entry = RECYCLER.get(); entry.ledgerId = ledgerEntry.getLedgerId(); entry.entryId = ledgerEntry.getEntryId(); entry.data = ledgerEntry.getEntryBuffer(); entry.data.retain(); entry.setRefCnt(1); return entry; }
void invalidateLedgerHandle(ReadHandle ledgerHandle, Throwable t) { long ledgerId = ledgerHandle.getId(); if (currentLedger != null && ledgerId != currentLedger.getId()) { // remove handle from ledger cache since we got a (read) error ledgerCache.remove(ledgerId); if (log.isDebugEnabled()) { log.debug("[{}] Removed ledger {} from cache (after read error)", name, ledgerId, t); } } else { if (log.isDebugEnabled()) { log.debug("[{}] Ledger that encountered read error is current ledger", name, t); } } }
@Override public CompletableFuture<Long> readLastAddConfirmedAsync() { return readHandle.readLastAddConfirmedAsync(); }
@Override public boolean isClosed() { return metadata.isClosed(); }
@Override public CompletableFuture<LedgerEntries> readUnconfirmedAsync(long firstEntry, long lastEntry) { return readHandle.readUnconfirmedAsync(firstEntry, lastEntry); }
@Override public CompletableFuture<Long> tryReadLastAddConfirmedAsync() { return readHandle.tryReadLastAddConfirmedAsync(); }
@Override public boolean isClosed() { return readHandle.isClosed(); }
public static ManagedLedgerException createManagedLedgerException(Throwable t) { if (t instanceof org.apache.bookkeeper.client.api.BKException) { return createManagedLedgerException(((org.apache.bookkeeper.client.api.BKException) t).getCode()); } else { return new ManagedLedgerException("Unknown exception"); } }
@Override public void asyncReadEntry(ReadHandle lh, long firstEntry, long lastEntry, boolean isSlowestReader, final ReadEntriesCallback callback, Object ctx) { try { asyncReadEntry0(lh, firstEntry, lastEntry, isSlowestReader, callback, ctx); } catch (Throwable t) { log.warn("failed to read entries for {}--{}-{}", lh.getId(), firstEntry, lastEntry, t); // invalidate all entries related to ledger from the cache (it might happen if entry gets corrupt // (entry.data is already deallocate due to any race-condition) so, invalidate cache and next time read from // the bookie) invalidateAllEntries(lh.getId()); callback.readEntriesFailed(createManagedLedgerException(t), ctx); } }
@Override public boolean isClosed() { return metadata.isClosed(); }
@Override public void asyncReadEntry(ReadHandle lh, PositionImpl position, final ReadEntryCallback callback, final Object ctx) { try { asyncReadEntry0(lh, position, callback, ctx); } catch (Throwable t) { log.warn("failed to read entries for {}-{}", lh.getId(), position, t); // invalidate all entries related to ledger from the cache (it might happen if entry gets corrupt // (entry.data is already deallocate due to any race-condition) so, invalidate cache and next time read from // the bookie) invalidateAllEntries(lh.getId()); callback.readEntryFailed(createManagedLedgerException(t), ctx); } }
@Override public CompletableFuture<Void> offload(ReadHandle ledger, UUID uuid, Map<String, String> extraMetadata) { CompletableFuture<Void> promise = new CompletableFuture<>(); if (offloads.putIfAbsent(ledger.getId(), uuid) == null) { promise.complete(null); } else { promise.completeExceptionally(new Exception("Already exists exception")); } return promise; }
@Override public CompletableFuture<Void> offload(ReadHandle ledger, UUID uuid, Map<String, String> extraMetadata) { return errorLedgers.thenCompose( (errors) -> { if (errors.contains(ledger.getId())) { CompletableFuture<Void> future = new CompletableFuture<>(); future.completeExceptionally(new Exception("Some kind of error")); return future; } else { return super.offload(ledger, uuid, extraMetadata); } }); } }
@Override public CompletableFuture<Void> offload(ReadHandle ledger, UUID uuid, Map<String, String> extraMetadata) { offloadStarted.countDown(); return blocker.thenCompose( (trimmedLedger) -> { if (trimmedLedger == ledger.getId()) { CompletableFuture<Void> future = new CompletableFuture<>(); future.completeExceptionally(new BKException.BKNoSuchLedgerExistsException()); return future; } else { return super.offload(ledger, uuid, extraMetadata); } }); } };