@Override public void operationComplete(Void result, Stat stat) { log.info("[{}] Updated cursor {} with ledger id {} md-position={} rd-position={}", ledger.getName(), name, lh.getId(), markDeletePosition, readPosition); final LedgerHandle oldLedger = cursorLedger; cursorLedger = lh; cursorLedgerStat = stat; // At this point the position had already been safely markdeleted callback.operationComplete(); asyncDeleteLedger(oldLedger); }
private void asyncDeleteLedger(long ledgerId, long retry) { if (retry <= 0) { log.warn("[{}] Failed to delete ledger after retries {}", name, ledgerId); return; } bookKeeper.asyncDeleteLedger(ledgerId, (rc, ctx) -> { if (rc == BKException.Code.NoSuchLedgerExistsException) { log.warn("[{}] Ledger was already deleted {}", name, ledgerId); } else if (rc != BKException.Code.OK) { log.error("[{}] Error deleting ledger {}", name, ledgerId, BKException.getMessage(rc)); scheduledExecutor.schedule(safeRun(() -> { asyncDeleteLedger(ledgerId, retry - 1); }), DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC, TimeUnit.SECONDS); } else { if (log.isDebugEnabled()) { log.debug("[{}] Deleted ledger {}", name, ledgerId); } } }, null); }
log.debug("[{}] Deleting ledger {}", name, ls); bookKeeper.asyncDeleteLedger(ls.getLedgerId(), (rc, ctx1) -> { switch (rc) { case BKException.Code.NoSuchLedgerExistsException:
public Future<Void> deleteLedger(long lid, final boolean ignoreNonExistentLedger) { BookKeeper bk; try { bk = get(); } catch (IOException ioe) { return Future.exception(ioe); } final Promise<Void> promise = new Promise<Void>(); bk.asyncDeleteLedger(lid, new AsyncCallback.DeleteCallback() { @Override public void deleteComplete(int rc, Object ctx) { if (BKException.Code.OK == rc) { promise.updateIfEmpty(new Return<Void>(null)); } else if (BKException.Code.NoSuchLedgerExistsException == rc) { if (ignoreNonExistentLedger) { promise.updateIfEmpty(new Return<Void>(null)); } else { promise.updateIfEmpty(new Throw<Void>(BKException.create(rc))); } } else { promise.updateIfEmpty(new Throw<Void>(BKException.create(rc))); } } }, null); return promise; }
bookKeeperClient.get().asyncDeleteLedger(ledgerMetadata.getLedgerId(), new AsyncCallback.DeleteCallback() { @Override public void deleteComplete(int rc, Object ctx) {
private void asyncDeleteLedger(final LedgerHandle lh, int retry) { if (lh == null || retry <= 0) { if (lh != null) { log.warn("[{}-{}] Failed to delete ledger after retries {}", ledger.getName(), name, lh.getId()); } return; } ledger.mbean.startCursorLedgerDeleteOp(); bookkeeper.asyncDeleteLedger(lh.getId(), (rc, ctx) -> { ledger.mbean.endCursorLedgerDeleteOp(); if (rc != BKException.Code.OK) { log.warn("[{}] Failed to delete ledger {}: {}", ledger.getName(), lh.getId(), BKException.getMessage(rc)); if (rc != BKException.Code.NoSuchLedgerExistsException) { ledger.getScheduledExecutor().schedule(safeRun(() -> { asyncDeleteLedger(lh, retry - 1); }), DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC, TimeUnit.SECONDS); } return; } else { log.info("[{}][{}] Successfully closed & deleted ledger {} in cursor", ledger.getName(), name, lh.getId()); } }, null); }
bookKeeper.asyncDeleteLedger(lh.getId(), (rc, ctx) -> { mbean.endDataLedgerDeleteOp(); log.info("[{}] Delete complete for empty ledger {}. rc={}", name, lh.getId(), rc);
private void asyncDeleteCursorLedger(int retry) { STATE_UPDATER.set(this, State.Closed); if (cursorLedger == null || retry <= 0) { if (cursorLedger != null) { log.warn("[{}-{}] Failed to delete ledger after retries {}", ledger.getName(), name, cursorLedger.getId()); } return; } ledger.mbean.startCursorLedgerDeleteOp(); bookkeeper.asyncDeleteLedger(cursorLedger.getId(), (rc, ctx) -> { ledger.mbean.endCursorLedgerDeleteOp(); if (rc == BKException.Code.OK) { log.info("[{}][{}] Deleted cursor ledger {}", ledger.getName(), name, cursorLedger.getId()); } else { log.warn("[{}][{}] Failed to delete ledger {}: {}", ledger.getName(), name, cursorLedger.getId(), BKException.getMessage(rc)); if (rc != BKException.Code.NoSuchLedgerExistsException) { ledger.getScheduledExecutor().schedule(safeRun(() -> { asyncDeleteCursorLedger(retry - 1); }), DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC, TimeUnit.SECONDS); } } }, null); }
} else { iterator.remove(); bookKeeper.asyncDeleteLedger(li.getLedgerId(), (rc, ctx) -> { if (log.isDebugEnabled()) { log.debug("[{}] Deleted empty ledger ledgerId={} rc={}", name, li.getLedgerId(), rc);
asyncDeleteLedger(ls.getLedgerId(), ls);
@Override public void deleteLedger(long ledgerID, Consumer<Integer> cb) { client.asyncDeleteLedger(ledgerID, (rc, ctx) -> { cb.accept(rc); }, null); }
@Override public void operationComplete(Void result, Stat stat) { log.info("[{}] Updated cursor {} with ledger id {} md-position={} rd-position={}", ledger.getName(), name, lh.getId(), markDeletePosition, readPosition); final LedgerHandle oldLedger = cursorLedger; cursorLedger = lh; cursorLedgerStat = stat; // At this point the position had already been safely markdeleted callback.operationComplete(); asyncDeleteLedger(oldLedger); }
@Override public void operationComplete(Void result, Stat stat) { log.info("[{}] Updated cursor {} with ledger id {} md-position={} rd-position={}", ledger.getName(), name, lh.getId(), markDeletePosition, readPosition); final LedgerHandle oldLedger = cursorLedger; cursorLedger = lh; cursorLedgerStat = stat; // At this point the position had already been safely markdeleted callback.operationComplete(); asyncDeleteLedger(oldLedger); }
private static CompletableFuture<Void> tryDeleteCompactedLedger(BookKeeper bk, long id) { CompletableFuture<Void> promise = new CompletableFuture<>(); bk.asyncDeleteLedger(id, (rc, ctx) -> { if (rc != BKException.Code.OK) { log.warn("Error deleting compacted topic ledger {}", id, BKException.create(rc)); } else { log.debug("Compacted topic ledger deleted successfully"); } promise.complete(null); // don't propagate any error }, null); return promise; }
private CompletableFuture<Void> deleteLedger(BookKeeper bk, LedgerHandle lh) { CompletableFuture<Void> bkf = new CompletableFuture<>(); bk.asyncDeleteLedger(lh.getId(), (rc, ctx) -> { if (rc != BKException.Code.OK) { bkf.completeExceptionally(BKException.create(rc)); } else { bkf.complete(null); } }, null); return bkf; }
/** * Synchronous call to delete a ledger. Parameters match those of * {@link #asyncDeleteLedger(long, AsyncCallback.DeleteCallback, Object)} * * @param lId * ledgerId * @throws InterruptedException * @throws BKException */ public void deleteLedger(long lId) throws InterruptedException, BKException { CompletableFuture<Void> future = new CompletableFuture<>(); SyncDeleteCallback result = new SyncDeleteCallback(future); // Call asynchronous version asyncDeleteLedger(lId, result, null); SyncCallbackUtils.waitForResult(future); }
private void asyncDeleteLedger(long ledgerId, long retry) { if (retry <= 0) { log.warn("[{}] Failed to delete ledger after retries {}", name, ledgerId); return; } bookKeeper.asyncDeleteLedger(ledgerId, (rc, ctx) -> { if (rc == BKException.Code.NoSuchLedgerExistsException) { log.warn("[{}] Ledger was already deleted {}", name, ledgerId); } else if (rc != BKException.Code.OK) { log.error("[{}] Error deleting ledger {}", name, ledgerId, BKException.getMessage(rc)); scheduledExecutor.schedule(safeRun(() -> { asyncDeleteLedger(ledgerId, retry - 1); }), DEFAULT_LEDGER_DELETE_BACKOFF_TIME_SEC, TimeUnit.SECONDS); } else { if (log.isDebugEnabled()) { log.debug("[{}] Deleted ledger {}", name, ledgerId); } } }, null); }
@Override public CompletableFuture<LogSegmentMetadata> deleteLogSegment(LogSegmentMetadata segment) { DeleteLogSegmentRequest request = new DeleteLogSegmentRequest(segment); BookKeeper bk; try { bk = this.bkc.get(); } catch (IOException e) { return FutureUtils.exception(e); } bk.asyncDeleteLedger(segment.getLogSegmentId(), this, request); return request.deletePromise; }
void asyncDeleteLedger(final LedgerHandle lh) { if (lh == null) { return; } ledger.mbean.startCursorLedgerDeleteOp(); bookkeeper.asyncDeleteLedger(lh.getId(), (rc, ctx) -> { ledger.getExecutor().submit(safeRun(() -> { ledger.mbean.endCursorLedgerDeleteOp(); if (rc != BKException.Code.OK) { log.warn("[{}] Failed to delete ledger {}: {}", ledger.getName(), lh.getId(), BKException.getMessage(rc)); return; } else { if (log.isDebugEnabled()) { log.debug("[{}][{}] Successfully closed&deleted ledger {} in cursor", ledger.getName(), name, lh.getId()); } } })); }, null); }
void asyncDeleteCursorLedger() { STATE_UPDATER.set(this, State.Closed); if (cursorLedger == null) { // No ledger was created return; } ledger.mbean.startCursorLedgerDeleteOp(); bookkeeper.asyncDeleteLedger(cursorLedger.getId(), (rc, ctx) -> { ledger.getExecutor().submit(safeRun(() -> { ledger.mbean.endCursorLedgerDeleteOp(); if (rc == BKException.Code.OK) { log.debug("[{}][{}] Deleted cursor ledger", cursorLedger.getId()); } else { log.warn("[{}][{}] Failed to delete ledger {}: {}", ledger.getName(), name, cursorLedger.getId(), BKException.getMessage(rc)); } })); }, null); }