@Override List<BookieSocketAddress> getCurrentEnsemble() { synchronized (metadataLock) { if (!newEnsemblesFromRecovery.isEmpty()) { return newEnsemblesFromRecovery.lastEntry().getValue(); } else { return super.getCurrentEnsemble(); } } }
public void asyncAddEntry(ByteBuf data, final AddCallback cb, final Object ctx) { PendingAddOp op = PendingAddOp.create(this, clientCtx, getCurrentEnsemble(), data, writeFlags, cb, ctx); doAsyncAddEntry(op); }
failedBookies, ledgerId); unsetSuccessAndSendWriteRequest(getCurrentEnsemble(), failedBookies.keySet()); return; toReplace.putAll(failedBookies); origEnsemble = getCurrentEnsemble();
/** * Make a recovery add entry request. Recovery adds can add to a ledger even * if it has been fenced. * * <p>This is only valid for bookie and ledger recovery, which may need to replicate * entries to a quorum of bookies to ensure data safety. * * <p>Normal client should never call this method. */ void asyncRecoveryAddEntry(final byte[] data, final int offset, final int length, final AddCallback cb, final Object ctx) { PendingAddOp op = PendingAddOp.create(this, clientCtx, getCurrentEnsemble(), Unpooled.wrappedBuffer(data, offset, length), writeFlags, cb, ctx) .enableRecoveryAdd(); doAsyncAddEntry(op); }
private boolean isWritesetWritable(DistributionSchedule.WriteSet writeSet, long key, int allowedNonWritableCount) { if (allowedNonWritableCount < 0) { allowedNonWritableCount = 0; } final int sz = writeSet.size(); final int requiredWritable = sz - allowedNonWritableCount; int nonWritableCount = 0; List<BookieSocketAddress> currentEnsemble = getCurrentEnsemble(); for (int i = 0; i < sz; i++) { if (!clientCtx.getBookieClient().isWritable(currentEnsemble.get(i), key)) { nonWritableCount++; if (nonWritableCount >= allowedNonWritableCount) { return false; } } else { final int knownWritable = i - nonWritableCount; if (knownWritable >= requiredWritable) { return true; } } } return true; }
public CompletableFuture<LedgerHandle> initiate() { ReadLastConfirmedOp rlcop = new ReadLastConfirmedOp(lh, clientCtx.getBookieClient(), lh.getCurrentEnsemble(), new ReadLastConfirmedOp.LastConfirmedDataCallback() { public void readLastConfirmedDataComplete(int rc, RecoveryData data) { if (rc == BKException.Code.OK) { synchronized (lh) { lh.lastAddPushed = lh.lastAddConfirmed = data.getLastAddConfirmed(); lh.length = data.getLength(); lh.pendingAddsSequenceHead = lh.lastAddConfirmed; startEntryToRead = endEntryToRead = lh.lastAddConfirmed; } // keep a copy of ledger metadata before proceeding // ledger recovery metadataForRecovery = lh.getLedgerMetadata(); doRecoveryRead(); } else if (rc == BKException.Code.UnauthorizedAccessException) { submitCallback(rc); } else { submitCallback(BKException.Code.ReadException); } } }); /** * Enable fencing on this op. When the read request reaches the bookies * server it will fence off the ledger, stopping any subsequent operation * from writing to it. */ rlcop.initiateWithFencing(); return promise; }
attempts.incrementAndGet(); List<BookieSocketAddress> currentEnsemble = getCurrentEnsemble(); List<BookieSocketAddress> newEnsemble = EnsembleUtils.replaceBookiesInEnsemble( clientCtx.getBookieWatcher(), metadata, currentEnsemble, failedBookies, logContext); newEnsemble = getCurrentEnsemble(); replaced = EnsembleUtils.diffEnsemble(origEnsemble, newEnsemble); LOG.info("New Ensemble: {} for ledger: {}", newEnsemble, ledgerId);
/** * Make a LastAddUpdate request. */ void asyncExplicitLacFlush(final long explicitLac) { final LastAddConfirmedCallback cb = LastAddConfirmedCallback.INSTANCE; final PendingWriteLacOp op = new PendingWriteLacOp(lh, clientCtx, lh.getCurrentEnsemble(), cb, null); op.setLac(explicitLac); try { if (LOG.isDebugEnabled()) { LOG.debug("Sending Explicit LAC: {}", explicitLac); } clientCtx.getMainWorkerPool().submit(new SafeRunnable() { @Override public void safeRun() { ByteBufList toSend = lh.macManager .computeDigestAndPackageForSendingLac(lh.getLastAddConfirmed()); op.initiate(toSend); } }); } catch (RejectedExecutionException e) { cb.addLacComplete(BookKeeper.getReturnRc(clientCtx.getBookieClient(), BKException.Code.InterruptedException), lh, null); } }
public CompletableFuture<Void> force() { CompletableFuture<Void> result = new CompletableFuture<>(); ForceLedgerOp op = new ForceLedgerOp(this, clientCtx.getBookieClient(), getCurrentEnsemble(), result); boolean wasClosed = false; synchronized (this) {
new TryReadLastConfirmedOp(this, clientCtx.getBookieClient(), getCurrentEnsemble(), innercb, getLastAddConfirmed()).initiate();
}; new ReadLastConfirmedOp(lh, clientCtx.getBookieClient(), lh.getCurrentEnsemble(), readLACCallback).initiate();
new ReadLastConfirmedOp(this, clientCtx.getBookieClient(), getCurrentEnsemble(), innercb).initiate();
new ReadLastConfirmedAndEntryOp(this, clientCtx, getCurrentEnsemble(), innercb, entryId - 1, timeOutInMillis) .parallelRead(parallel) .initiate();
new PendingReadLacOp(this, clientCtx.getBookieClient(), getCurrentEnsemble(), innercb).initiate();