@Override public Future<BKLogWriteHandler> apply(ZKLogMetadataForWriter logMetadata) { Promise<BKLogWriteHandler> createPromise = new Promise<BKLogWriteHandler>(); createWriteHandler(logMetadata, lockHandler, createPromise); return createPromise; } });
@Override public void onFailure(Throwable cause) { if (cause instanceof LogEmptyException) { dlsnPromise.setValue(DLSN.InitialDLSN); } else { dlsnPromise.setException(cause); } } });
@Override public void run() { result.become(doDeleteAndRemoveAsync(stream)); } }, 0);
ListFutureProcessor(List<T> items, Function<T, Future<R>> processFunc, ExecutorService callbackExecutor) { this.itemsIter = items.iterator(); this.processFunc = processFunc; this.promise = new Promise<List<R>>(); this.promise.setInterruptHandler(this); this.results = new ArrayList<R>(); this.callbackExecutor = callbackExecutor; }
protected void setResponse(Response response) { Return<Response> responseTry = new Return(response); boolean isEmpty = result.updateIfEmpty(responseTry); if (!isEmpty) { Option<Try<Response>> resultTry = result.poll(); logger.error("Result set multiple times. Value='{}', New='{}'", resultTry, responseTry); } }
closeFuture = closePromise = new Promise<Void>(); final Promise<Void> closeWaiterFuture = new Promise<Void>(); closeWaiterFuture.addEventListener(OrderedFutureEventListener.of(new FutureEventListener<Void>() { @Override public void onSuccess(Void value) {
final Promise<String> lockResult = new Promise<String>(); lockResult.addEventListener(new FutureEventListener<String>() { @Override public void onSuccess(String currentOwner) { result.setValue(currentOwner);
private Future<LogSegmentMetadata> deleteLogSegment( final LogSegmentMetadata ledgerMetadata) { LOG.info("Deleting ledger {} for {}", ledgerMetadata, getFullyQualifiedName()); final Promise<LogSegmentMetadata> promise = new Promise<LogSegmentMetadata>(); final Stopwatch stopwatch = Stopwatch.createStarted(); promise.addEventListener(new FutureEventListener<LogSegmentMetadata>() { @Override public void onSuccess(LogSegmentMetadata segment) { promise.setException(BKException.create(BKException.Code.BookieHandleNotAvailableException));
Future<List<String>> getLogSegmentNames(String logSegmentsPath, Watcher watcher) { Promise<List<String>> result = new Promise<List<String>>(); try { zkc.get().getChildren(logSegmentsPath, watcher, this, result); } catch (ZooKeeperClient.ZooKeeperConnectionException e) { result.setException(FutureUtils.zkException(e, logSegmentsPath)); } catch (InterruptedException e) { result.setException(FutureUtils.zkException(e, logSegmentsPath)); } return result; }
Future<Void> result() { return result.map(new AbstractFunction1<WriteResponse, Void>() { @Override public Void apply(WriteResponse response) { return null; } }); } }
@Override public void onSuccess(LogRecordWithDLSN record) { if (null == record) { asyncGetLastLogRecord(ledgerIter, promise, fence, includeControlRecord, includeEndOfStream); } else { promise.setValue(record); } }
@Override public Future<LockWaiter> asyncTryLock(final long timeout, final TimeUnit unit) { final Promise<String> result = new Promise<String>(); final boolean wait = DistributedLogConstants.LOCK_IMMEDIATE != timeout; if (wait) { final Promise<Boolean> waiterAcquireFuture = new Promise<Boolean>(new com.twitter.util.Function<Throwable, BoxedUnit>() { @Override public BoxedUnit apply(Throwable t) { return result.map(new AbstractFunction1<String, LockWaiter>() { @Override public LockWaiter apply(final String currentOwner) {
@Override public void onFailure(Throwable cause) { promise.setException(cause); } });
@Override public void createComplete(int rc, LedgerHandle lh, Object ctx) { if (BKException.Code.OK == rc) { promise.updateIfEmpty(new Return<LedgerHandle>(lh)); } else { promise.updateIfEmpty(new Throw<LedgerHandle>(BKException.create(rc))); } } }, null);
/** * @see com.twitter.util.Awaitable#isReady(com.twitter.util.Awaitable.CanAwait) */ @Override public boolean isReady(CanAwait permit) { return onClose.isReady(permit); } }
/** * Register a transmit complete listener. * <p>The listener will be triggered with transmit result when transmit completes. * The method should be non-blocking. * * @param transmitCompleteListener * listener on transmit completion * @see #awaitTransmitComplete(long, TimeUnit) */ void addTransmitCompleteListener(FutureEventListener<Integer> transmitCompleteListener) { transmitComplete.addEventListener(transmitCompleteListener); }
void doInternalReacquireLock(final AtomicInteger numRetries, final long lockTimeout, final Promise<ZKDistributedLock> reacquirePromise) { internalTryRetries.inc(); Promise<ZKDistributedLock> tryPromise = new Promise<ZKDistributedLock>(); tryPromise.addEventListener(new FutureEventListener<ZKDistributedLock>() { @Override public void onSuccess(ZKDistributedLock lock) { FutureUtils.setValue(reacquirePromise, lock); } @Override public void onFailure(Throwable cause) { if (cause instanceof OwnershipAcquireFailedException) { // the lock has been acquired by others FutureUtils.setException(reacquirePromise, cause); } else { if (numRetries.getAndDecrement() > 0 && !closed) { internalReacquireLock(numRetries, lockTimeout, reacquirePromise); } else { FutureUtils.setException(reacquirePromise, cause); } } } }); doAsyncAcquireWithSemaphore(tryPromise, 0); }
promise.setValue(BoxedUnit.UNIT); return; promise.setValue(BoxedUnit.UNIT); return; Promise<BoxedUnit> deletePromise = new Promise<BoxedUnit>(); deleteLockNode(deletePromise); deletePromise.addEventListener(new FutureEventListener<BoxedUnit>() { @Override public void onSuccess(BoxedUnit complete) {
Future<Void> result() { return result.map(new AbstractFunction1<WriteResponse, Void>() { @Override public Void apply(WriteResponse response) { return null; } }); } }