@Override public void closeFailed(ManagedLedgerException exception, Object ctx) { log.warn("[{}] Closing ledger failed for cursor {}", ledger.getName(), name, exception); result.exception = exception; latch.countDown(); } }, null);
@Override public void closeComplete(Object ctx) { if (log.isDebugEnabled()) { log.debug("[{}] Successfully closed ledger for cursor {}", ledger.getName(), name); } latch.countDown(); }
@Override public void deleteComplete(Object ctx) { if (timeout.get()) { log.warn("[{}] [{}] Delete operation timeout. Callback deleteComplete at position {}", ledger.getName(), name, positions); } counter.countDown(); }
@Override public void deleteFailed(ManagedLedgerException exception, Object ctx) { result.exception = exception; if (timeout.get()) { log.warn("[{}] [{}] Delete operation timeout. Callback deleteFailed at position {}", ledger.getName(), name, positions); } counter.countDown(); } }, null);
@Override public synchronized String toString() { return MoreObjects.toStringHelper(this).add("ledger", ledger.getName()).add("ackPos", markDeletePosition) .add("readPos", readPosition).toString(); }
@Override public synchronized String toString() { return MoreObjects.toStringHelper(this).add("ledger", ledger.getName()).add("name", name) .add("ackPos", markDeletePosition).add("readPos", readPosition).toString(); }
@Override public synchronized void readEntryFailed(ManagedLedgerException mle, Object ctx) { log.warn("[{}][{}] Error while replaying entries", ledger.getName(), name, mle); if (exception.compareAndSet(null, mle)) { // release the entries just once, any further read success will release the entry straight away entries.forEach(Entry::release); } if (--pendingCallbacks == 0) { callback.readEntriesFailed(exception.get(), ctx); } } };
@Override public void rewind() { lock.writeLock().lock(); try { PositionImpl newReadPosition = ledger.getNextValidPosition(markDeletePosition); PositionImpl oldReadPosition = readPosition; log.info("[{}-{}] Rewind from {} to {}", ledger.getName(), name, oldReadPosition, newReadPosition); readPosition = newReadPosition; } finally { lock.writeLock().unlock(); } }
@Override public boolean cancelPendingReadRequest() { if (log.isDebugEnabled()) { log.debug("[{}] [{}] Cancel pending read request", ledger.getName(), name); } return WAITING_READ_OP_UPDATER.getAndSet(this, null) != null; }
public EntryCacheImpl(EntryCacheManager manager, ManagedLedgerImpl ml) { this.manager = manager; this.ml = ml; this.entries = new RangeCache<>(entryWeighter); if (log.isDebugEnabled()) { log.debug("[{}] Initialized managed-ledger entry cache", ml.getName()); } }
@Override public void operationComplete() { log.info("[{}][{}] Updated md-position={} into cursor-ledger {}", ledger.getName(), name, markDeletePosition, cursorLedger.getId()); callback.closeComplete(ctx); }
@Override public void operationComplete(Void result, Stat stat) { log.info("[{}][{}] Closed cursor at md-position={}", ledger.getName(), name, markDeletePosition); // At this point the position had already been safely stored in the cursor z-node callback.closeComplete(ctx); asyncDeleteLedger(cursorLedger); }
@Override public void skipEntries(int numEntriesToSkip) { log.info("[{}] Skipping {} entries on read-only cursor {}", ledger.getName(), numEntriesToSkip); readPosition = ledger.getPositionAfterN(readPosition, numEntriesToSkip, PositionBound.startIncluded).getNext(); }
@Override public void invalidateEntries(final PositionImpl lastPosition) { final PositionImpl firstPosition = PositionImpl.get(-1, 0); Pair<Integer, Long> removed = entries.removeRange(firstPosition, lastPosition, true); int entriesRemoved = removed.getLeft(); long sizeRemoved = removed.getRight(); if (log.isDebugEnabled()) { log.debug("[{}] Invalidated entries up to {} - Entries removed: {} - Size removed: {}", ml.getName(), lastPosition, entriesRemoved, sizeRemoved); } manager.entriesRemoved(sizeRemoved); }
public EntryCache getEntryCache(ManagedLedgerImpl ml) { if (maxSize == 0) { // Cache is disabled return new EntryCacheDisabled(ml); } EntryCache newEntryCache = new EntryCacheImpl(this, ml); EntryCache currentEntryCache = caches.putIfAbsent(ml.getName(), newEntryCache); if (currentEntryCache != null) { return currentEntryCache; } else { return newEntryCache; } }
@Override public void invalidateAllEntries(long ledgerId) { final PositionImpl firstPosition = PositionImpl.get(ledgerId, 0); final PositionImpl lastPosition = PositionImpl.get(ledgerId + 1, 0); Pair<Integer, Long> removed = entries.removeRange(firstPosition, lastPosition, false); int entriesRemoved = removed.getLeft(); long sizeRemoved = removed.getRight(); if (log.isDebugEnabled()) { log.debug("[{}] Invalidated all entries on ledger {} - Entries removed: {} - Size removed: {}", ml.getName(), ledgerId, entriesRemoved, sizeRemoved); } manager.entriesRemoved(sizeRemoved); }
@Override public void operationFailed(ManagedLedgerException e) { log.warn("[{}][{}] Failed to persist mark-delete position into cursor-ledger{}: {}", ledger.getName(), name, cursorLedger.getId(), e.getMessage()); callback.closeFailed(e, ctx); } });
@Override public void asyncClose(final AsyncCallbacks.CloseCallback callback, final Object ctx) { State oldState = STATE_UPDATER.getAndSet(this, State.Closed); if (oldState == State.Closed) { log.info("[{}] [{}] State is already closed", ledger.getName(), name); callback.closeComplete(ctx); return; } persistPosition(-1, lastMarkDeleteEntry.newPosition, lastMarkDeleteEntry.properties, callback, ctx); }
@BeforeMethod public void setUp(Method method) throws Exception { super.setUp(method); ml = mock(ManagedLedgerImpl.class); when(ml.getName()).thenReturn("name"); when(ml.getExecutor()).thenReturn(executor); when(ml.getMBean()).thenReturn(new ManagedLedgerMBeanImpl(ml)); }
@Override public long getNumberOfEntries() { if (readPosition.compareTo(ledger.getLastPosition().getNext()) > 0) { if (log.isDebugEnabled()) { log.debug("[{}] [{}] Read position {} is ahead of last position {}. There are no entries to read", ledger.getName(), name, readPosition, ledger.getLastPosition()); } return 0; } else { return getNumberOfEntries(Range.closedOpen(readPosition, ledger.getLastPosition().getNext())); } }