@Override public void closeComplete(int rc, LedgerHandle lh, Object ctx) { if (BKException.Code.OK != rc && BKException.Code.LedgerClosedException != rc) { if (!abort) { throwExc.set(new IOException("Failed to close ledger for " + fullyQualifiedLogSegment + " : " + BKException.getMessage(rc))); } } completeClosePromise(abort, throwExc, closePromise); } }, null);
/** * Create transmit exception from transmit result. * * @param transmitResult * transmit result (basically bk exception code) * @return transmit exception */ public static BKTransmitException transmitException(int transmitResult) { return new BKTransmitException("Failed to write to bookkeeper; Error is (" + transmitResult + ") " + BKException.getMessage(transmitResult), transmitResult); }
public static ManagedLedgerException createManagedLedgerException(int bkErrorCode) { if (bkErrorCode == BKException.Code.TooManyRequestsException) { return new TooManyRequestsException("Too many request error from bookies"); } else if (isBkErrorNotRecoverable(bkErrorCode)) { return new NonRecoverableLedgerException(BKException.getMessage(bkErrorCode)); } else { return new ManagedLedgerException(BKException.getMessage(bkErrorCode)); } }
@Override public void run() { while (!ledgers.isEmpty()) { long lid = -1L; try { lid = ledgers.take(); System.out.println("Recovering ledger " + lid); bkAdmin.recoverBookieData(lid, bookieAddrs, dryrun, skipOpenLedgers); System.out.println("Recovered ledger completed : " + lid + ", " + numPendings.decrementAndGet() + " left"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); doneLatch.countDown(); break; } catch (BKException ke) { System.out.println("Recovered ledger failed : " + lid + ", rc = " + BKException.getMessage(ke.getCode())); } } doneLatch.countDown(); } };
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 List<InputSplit> getSplits(JobContext jobContext) throws IOException, InterruptedException { List<LogSegmentMetadata> segments = dlm.getLogSegments(); List<InputSplit> inputSplits = Lists.newArrayListWithCapacity(segments.size()); BookKeeper bk = namespace.getReaderBKC().get(); LedgerManager lm = BookKeeperAccessor.getLedgerManager(bk); final AtomicInteger rcHolder = new AtomicInteger(0); final AtomicReference<LedgerMetadata> metadataHolder = new AtomicReference<LedgerMetadata>(null); for (LogSegmentMetadata segment : segments) { final CountDownLatch latch = new CountDownLatch(1); lm.readLedgerMetadata(segment.getLedgerId(), new BookkeeperInternalCallbacks.GenericCallback<LedgerMetadata>() { @Override public void operationComplete(int rc, LedgerMetadata ledgerMetadata) { metadataHolder.set(ledgerMetadata); rcHolder.set(rc); latch.countDown(); } }); latch.await(); if (BKException.Code.OK != rcHolder.get()) { throw new IOException("Faild to get log segment metadata for " + segment + " : " + BKException.getMessage(rcHolder.get())); } inputSplits.add(new LogSegmentSplit(segment, metadataHolder.get())); } return inputSplits; }
System.out.println("Eid = " + rr.getEntryId() + ", Lac = " + rr.getValue()); } else { System.out.println("status = " + BKException.getMessage(rr.getResultCode()));
BKException.getMessage(rc)); int toDelete = ledgersToDelete.get(); if (toDelete != -1 && ledgersToDelete.compareAndSet(toDelete, -1)) {
System.out.println("status = " + BKException.getMessage(rr.getResultCode())); System.out.println("\t-------------------------------"); printEntry(reader); } else { System.out.println("status = " + BKException.getMessage(rr.getResultCode()));
mbean.endDataLedgerOpenOp(); if (log.isDebugEnabled()) { log.debug("[{}] Opened ledger {}: ", name, id, BKException.getMessage(rc)); initializeBookKeeper(callback); } else { log.error("[{}] Failed to open ledger {}: {}", name, id, BKException.getMessage(rc)); callback.initializeFailed(createManagedLedgerException(rc)); return;
if (rc != BKException.Code.OK) { log.warn("[{}] Error creating ledger for cursor {}: {}", ledger.getName(), name, BKException.getMessage(rc)); callback.operationFailed(new ManagedLedgerException(BKException.getMessage(rc))); return;
@Override public void closeComplete(int rc, LedgerHandle lh, Object ctx) { checkArgument(ledger.getId() == lh.getId(), "ledgerId %s doesn't match with acked ledgerId %s", ledger.getId(), lh.getId()); if (rc == BKException.Code.OK) { log.debug("Successfuly closed ledger {}", lh.getId()); } else { log.warn("Error when closing ledger {}. Status={}", lh.getId(), BKException.getMessage(rc)); } ml.ledgerClosed(lh); updateLatency(); AddEntryCallback cb = callbackUpdater.getAndSet(this, null); if (cb != null) { cb.addComplete(PositionImpl.get(lh.getId(), entryId), ctx); ml.notifyCursors(); this.recycle(); } }
LOG.error("Log Segment {} Trying to write to an errored stream; Error is {}", fullyQualifiedLogSegment, BKException.getMessage(transmitResult.get())); throw new BKTransmitException("Trying to write to an errored stream;" + " Error code : (" + transmitResult.get() + ") " + BKException.getMessage(transmitResult.get()), transmitResult.get());
BKException.getMessage(rc)); } else if (rc != BKException.Code.OK) { log.warn("[{}] Error opening metadata ledger {} for consumer {}: {}", ledger.getName(), ledgerId, name, BKException.getMessage(rc)); callback.operationFailed(new ManagedLedgerException(BKException.getMessage(rc))); return; ledgerId, name, BKException.getMessage(rc1)); } else if (rc1 != BKException.Code.OK) { log.warn("[{}] Error reading from metadata ledger {} for consumer {}: {}", ledger.getName(), ledgerId, name, BKException.getMessage(rc1));
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); }
} else { log.warn("[{}] Error updating cursor {} position {} in meta-ledger {}: {}", ledger.getName(), name, position, lh1.getId(), BKException.getMessage(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); }
latch1.await(config.getReadEntryTimeoutSeconds() + 2, TimeUnit.SECONDS); assertNotNull(responseException1.get()); assertEquals(responseException1.get().getMessage(), BKException.getMessage(BKException.Code.TimeoutException)); latch2.await(config.getReadEntryTimeoutSeconds() + 2, TimeUnit.SECONDS); assertNotNull(responseException2.get()); assertEquals(responseException2.get().getMessage(), BKException.getMessage(BKException.Code.TimeoutException));
log.error("[{}] Error creating ledger rc={} {}", name, rc, BKException.getMessage(rc)); ManagedLedgerException status = createManagedLedgerException(rc);
synchronized private Future<DLSN> writeUserRecord(LogRecord record) throws IOException { if (null != closeFuture) { throw new WriteException(fullyQualifiedLogSegment, BKException.getMessage(BKException.Code.LedgerClosedException)); throw new WriteException(fullyQualifiedLogSegment, BKException.getMessage(transmitResult.get()));