/** * Cancel the future. It would interrupt the future. * * @param future future to cancel */ public static <T> void cancel(Future<T> future) { future.raise(new FutureCancelledException()); }
/** * Await for the transmit to be complete * * @param timeout * wait timeout * @param unit * wait timeout unit */ int awaitTransmitComplete(long timeout, TimeUnit unit) throws Exception { return Await.result(transmitComplete, Duration.fromTimeUnit(timeout, unit)); }
@Override public Future<byte[]> apply(ThriftClientRequest request) { return Future.value(request.message); } }
@Override public void onFailure(Throwable cause) { if (cause instanceof LogEmptyException) { dlsnPromise.setValue(DLSN.InitialDLSN); } else { dlsnPromise.setException(cause); } } });
public MovingAverageRateFactory(Timer timer) { this.avgs = new CopyOnWriteArrayList<SampledMovingAverageRate>(); this.timer = timer; Function0<BoxedUnit> sampleTask = new Function0<BoxedUnit>() { public BoxedUnit apply() { sampleAll(); return null; } }; this.timerTask = timer.schedulePeriodically( Time.now(), Duration.fromSeconds(DEFAULT_INTERVAL_SECS), sampleTask); }
@Override public void onFailure(Throwable cause) { promise.setException(cause); } });
@Override public Future<BKLogWriteHandler> apply(ZKLogMetadataForWriter logMetadata) { Promise<BKLogWriteHandler> createPromise = new Promise<BKLogWriteHandler>(); createWriteHandler(logMetadata, lockHandler, createPromise); return createPromise; } });
private void advance(TimeControl time, MockTimer timer, int timeMs) { Duration duration = Duration.fromMilliseconds(timeMs); time.advance(duration); timer.tick(); }
@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);
Future<Boolean> result() { return result.map(new AbstractFunction1<WriteResponse, Boolean>() { @Override public Boolean apply(WriteResponse response) { return true; } }); } }
@Override public Future<List<Try<DLSN>>> apply(List<Future<DLSN>> results) { return Future$.MODULE$.collectToTry(results); } });
@Override public void run() { listener.onFailure(cause); } });
void withCurrentTimeFrozen(final TcCallback cb) { Time$.MODULE$.withCurrentTimeFrozen(new Function<TimeControl, BoxedUnit>() { @Override public BoxedUnit apply(TimeControl time) { cb.apply(time); return BoxedUnit.UNIT; } }); }
@Override public void onFailure(Throwable cause) { promise.setException(cause); } }
PendingLogRecord(LogRecord record, boolean flush) { this.record = record; this.promise = new Promise<DLSN>(); this.flush = flush; }
@Override public void onFailure(Throwable cause) { promise.setException(cause); } });
@Override public void onFailure(Throwable cause) { postCheckedPromise.setException(cause); } });
@Override public void onFailure(Throwable cause) { createPromise.setException(cause); } });
@Override public void onFailure(Throwable cause) { createPromise.setException(cause); } });