@Override public void run() { long count = 0; try { Iterator<String> keysIterator = createKeysIterator(entry, pattern, batchSize); List<String> keys = new ArrayList<String>(); while (keysIterator.hasNext()) { String key = keysIterator.next(); keys.add(key); if (keys.size() % batchSize == 0) { count += delete(keys.toArray(new String[keys.size()])); keys.clear(); } } if (!keys.isEmpty()) { count += delete(keys.toArray(new String[keys.size()])); keys.clear(); } Future<Long> future = ImmediateEventExecutor.INSTANCE.newSucceededFuture(count); future.addListener(listener); } catch (Exception e) { Future<Long> future = ImmediateEventExecutor.INSTANCE.newFailedFuture(e); future.addListener(listener); } } });
@Override public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) { return terminationFuture(); }
final Promise<List<InetSocketAddress>> promise = ImmediateEventExecutor.INSTANCE.newPromise();
/** * Receives a message from this pipe. * <p> * If the pipe is closed then this will return a failed future.</p> */ public Future<T> receive() { Node node; synchronized (this) { node = sendQueue.poll(); if (node == null) { if (closed) { return ImmediateEventExecutor.INSTANCE.newFailedFuture(PIPE_CLOSED); } Promise<T> promise = ImmediateEventExecutor.INSTANCE.newPromise(); receiveQueue.add(promise); return promise; } } node.promise.setSuccess(null); return ImmediateEventExecutor.INSTANCE.newSucceededFuture(node.message); }
@Override public Future<Void> sendCloseFrame(int statusCode, String reasonText) { if (channel.isOpen()) { return channel.writeAndFlush(new CloseWebSocketFrame(1000, "normal closure")); } return ImmediateEventExecutor.INSTANCE.newSucceededFuture(null); }
workerShutdownFuture = config.workerGroup().shutdownGracefully(); } else { workerShutdownFuture = ImmediateEventExecutor.INSTANCE.newSucceededFuture(null);
@Override public void run() { long count = 0; try { Iterator<String> keysIterator = createKeysIterator(entry, pattern, batchSize); List<String> keys = new ArrayList<String>(); while (keysIterator.hasNext()) { String key = keysIterator.next(); keys.add(key); if (keys.size() % batchSize == 0) { count += delete(keys.toArray(new String[keys.size()])); keys.clear(); } } if (!keys.isEmpty()) { count += delete(keys.toArray(new String[keys.size()])); keys.clear(); } Future<Long> future = ImmediateEventExecutor.INSTANCE.newSucceededFuture(count); future.addListener(listener); } catch (Exception e) { Future<Long> future = ImmediateEventExecutor.INSTANCE.newFailedFuture(e); future.addListener(listener); } } });
private void stop1(CompletableFuture<Void> future, EventLoopGroup bossGroup) { final Future<?> bossShutdownFuture; if (bossGroup != null) { bossShutdownFuture = bossGroup.shutdownGracefully(); this.bossGroup = null; } else { bossShutdownFuture = ImmediateEventExecutor.INSTANCE.newSucceededFuture(null); } bossShutdownFuture.addListener(f1 -> { // All server ports have been unbound. primaryActivePort = null; activePorts.clear(); // Shut down the workers. final EventLoopGroup workerGroup = this.workerGroup; final Future<?> workerShutdownFuture; if (workerGroup != null) { workerShutdownFuture = workerGroup.shutdownGracefully(); this.workerGroup = null; } else { workerShutdownFuture = ImmediateEventExecutor.INSTANCE.newSucceededFuture(null); } workerShutdownFuture.addListener(f2 -> { stateManager.enter(State.STOPPED); completeFuture(future); }); }); }
@Override public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) { return terminationFuture(); }
public Future<Bootstrap> getBootstrap(Uri uri, NameResolver<InetAddress> nameResolver, ProxyServer proxy) { final Promise<Bootstrap> promise = ImmediateEventExecutor.INSTANCE.newPromise();
@Override public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) { shutdown(); if (isShutdown()) { return ImmediateEventExecutor.INSTANCE.newSucceededFuture(null); } else { return ImmediateEventExecutor.INSTANCE.newFailedFuture(new TimeoutException()); } }
@Override public Future<Channel> getConnection(ConnectionParameters connectionParameters, HostAndPort address) { return ImmediateEventExecutor.INSTANCE.newSucceededFuture(new EmbeddedChannel()); }
@Override public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) { return terminationFuture(); }
private <T> Future<List<InetSocketAddress>> resolveAddresses(Request request, ProxyServer proxy, NettyResponseFuture<T> future, AsyncHandler<T> asyncHandler) { Uri uri = request.getUri(); final Promise<List<InetSocketAddress>> promise = ImmediateEventExecutor.INSTANCE.newPromise(); if (proxy != null && !proxy.isIgnoredForHost(uri.getHost()) && proxy.getProxyType().isHttp()) { int port = uri.isSecured() ? proxy.getSecuredPort() : proxy.getPort(); InetSocketAddress unresolvedRemoteAddress = InetSocketAddress.createUnresolved(proxy.getHost(), port); scheduleRequestTimeout(future, unresolvedRemoteAddress); return RequestHostnameResolver.INSTANCE.resolve(request.getNameResolver(), unresolvedRemoteAddress, asyncHandler); } else { int port = uri.getExplicitPort(); InetSocketAddress unresolvedRemoteAddress = InetSocketAddress.createUnresolved(uri.getHost(), port); scheduleRequestTimeout(future, unresolvedRemoteAddress); if (request.getAddress() != null) { // bypass resolution InetSocketAddress inetSocketAddress = new InetSocketAddress(request.getAddress(), port); return promise.setSuccess(singletonList(inetSocketAddress)); } else { return RequestHostnameResolver.INSTANCE.resolve(request.getNameResolver(), unresolvedRemoteAddress, asyncHandler); } } }
@Override public void run() { long count = 0; try { Iterator<String> keysIterator = createKeysIterator(entry, pattern, batchSize); List<String> keys = new ArrayList<String>(); while (keysIterator.hasNext()) { String key = keysIterator.next(); keys.add(key); if (keys.size() % batchSize == 0) { count += delete(keys.toArray(new String[keys.size()])); keys.clear(); } } if (!keys.isEmpty()) { count += delete(keys.toArray(new String[keys.size()])); keys.clear(); } Future<Long> future = ImmediateEventExecutor.INSTANCE.newSucceededFuture(count); future.addListener(listener); } catch (Exception e) { Future<Long> future = ImmediateEventExecutor.INSTANCE.newFailedFuture(e); future.addListener(listener); } } });
@Override public Future<Channel> getConnection(ConnectionParameters connectionParameters, HostAndPort address) { return ImmediateEventExecutor.INSTANCE.newSucceededFuture(new EmbeddedChannel()); }
@Override public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) { return terminationFuture(); }
private static Promise<ContextInfo> createContextInfo(final URI uri) { String[] userInfo = uri.getUserInfo().split(":", 2); ImmediateEventExecutor executor = ImmediateEventExecutor.INSTANCE; Promise<ContextInfo> promise = executor.newPromise(); promise.setSuccess(new ContextInfo(uri.getHost(), uri.getPort(), userInfo[0], userInfo[1])); return promise; }
@Override public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) { return terminationFuture(); }
/** * Sends a message to this pipe. Returns a {@link Future} that is completed * when the message is received. * <p> * If the pipe is closed then this will return a failed future.</p> * * @param message the message to send to the pipe * @return a {@link Future} that is satisfied when the message is received, * or a failed future if the pipe is closed. * @throws NullPointerException if the message is {@code null}. * @throws IllegalStateException if the message could not be added to the queue for some reason. * @see #receive() */ public Future<Void> send(T message) { Objects.requireNonNull(message, "msg"); Promise<T> receivePromise; synchronized (this) { if (closed) { return CLOSED_FUTURE; } receivePromise = receiveQueue.poll(); if (receivePromise == null) { Promise<Void> sendPromise = ImmediateEventExecutor.INSTANCE.newPromise(); sendQueue.add(new Node(message, sendPromise)); return sendPromise; } } receivePromise.setSuccess(message); return SENT_FUTURE; }