@Override public ChannelPromise setSuccess(Void result) { super.setSuccess(result); return this; }
@Override public ProgressivePromise<V> setSuccess(V result) { super.setSuccess(result); return this; }
protected final Promise<V> setSuccessInternal(V result) { super.setSuccess(result); return this; }
private void setSuccess0() { super.setSuccess(null); }
@Override public ProgressivePromise<V> setSuccess(V result) { super.setSuccess(result); return this; }
@Override public ChannelPromise setSuccess(Void result) { super.setSuccess(result); return this; }
protected final Promise<V> setSuccessInternal(V result) { super.setSuccess(result); return this; }
private void setSuccess0() { super.setSuccess(null); }
private void setSuccess0() { super.setSuccess(null); }
@Override public ChannelPromise setSuccess(Void result) { super.setSuccess(result); return this; }
@Override public ProgressivePromise<V> setSuccess(V result) { super.setSuccess(result); return this; }
protected final Promise<V> setSuccessInternal(V result) { super.setSuccess(result); return this; }
/** * Create a promise that emits a {@code Boolean} value on completion of the {@code future} * * @param future the future. * @return Promise emitting a {@code Boolean} value. {@literal true} if the {@code future} completed successfully, otherwise * the cause wil be transported. */ static Promise<Boolean> toBooleanPromise(Future<?> future) { DefaultPromise<Boolean> result = new DefaultPromise<>(GlobalEventExecutor.INSTANCE); if (future.isDone() || future.isCancelled()) { if (future.isSuccess()) { result.setSuccess(true); } else { result.setFailure(future.cause()); } return result; } future.addListener((GenericFutureListener<Future<Object>>) f -> { if (f.isSuccess()) { result.setSuccess(true); } else { result.setFailure(f.cause()); } }); return result; }
@Override public Promise<Boolean> release(EventExecutorGroup eventLoopGroup, long quietPeriod, long timeout, TimeUnit unit) { logger.debug("Release executor {}", eventLoopGroup); Class<?> key = getKey(release(eventLoopGroup)); if ((key == null && eventLoopGroup.isShuttingDown()) || refCounter.containsKey(eventLoopGroup)) { DefaultPromise<Boolean> promise = new DefaultPromise<Boolean>(GlobalEventExecutor.INSTANCE); promise.setSuccess(true); return promise; } if (key != null) { eventLoopGroups.remove(key); } Future<?> shutdownFuture = eventLoopGroup.shutdownGracefully(quietPeriod, timeout, unit); return toBooleanPromise(shutdownFuture); }
@Override @SuppressWarnings("unchecked") public Future<Boolean> shutdown(long quietPeriod, long timeout, TimeUnit timeUnit) { logger.debug("Initiate shutdown ({}, {}, {})", quietPeriod, timeout, timeUnit); shutdownCalled = true; Map<Class<? extends EventExecutorGroup>, EventExecutorGroup> copy = new HashMap<>(eventLoopGroups); DefaultPromise<Boolean> overall = new DefaultPromise<>(GlobalEventExecutor.INSTANCE); DefaultPromise<Boolean> lastRelease = new DefaultPromise<>(GlobalEventExecutor.INSTANCE); Futures.PromiseAggregator<Boolean, Promise<Boolean>> aggregator = new Futures.PromiseAggregator<>(overall); aggregator.expectMore(1 + copy.size()); aggregator.arm(); for (EventExecutorGroup executorGroup : copy.values()) { Promise<Boolean> shutdown = toBooleanPromise(release(executorGroup, quietPeriod, timeout, timeUnit)); aggregator.add(shutdown); } aggregator.add(lastRelease); lastRelease.setSuccess(null); return toBooleanPromise(overall); } }
@Override public ProgressivePromise<V> setSuccess(V result) { super.setSuccess(result); return this; }
protected final Promise<V> setSuccessInternal(V result) { super.setSuccess(result); return this; }
lastRelease.setSuccess(null);
@Override @SuppressWarnings("FutureReturnValueIgnored") public ChannelPromise setSuccess(Void result) { // Returned value is deliberately ignored super.setSuccess(result); return this; }
@Override public ChannelPromise setSuccess(Void result) { super.setSuccess(result); return this; }