final Promise<List<InetSocketAddress>> promise = ImmediateEventExecutor.INSTANCE.newPromise();
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); } } }
public Future<Bootstrap> getBootstrap(Uri uri, NameResolver<InetAddress> nameResolver, ProxyServer proxy) { final Promise<Bootstrap> promise = ImmediateEventExecutor.INSTANCE.newPromise();
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; }
/** * 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; }
RSCClient(RSCConf conf, Promise<ContextInfo> ctx) throws IOException { this.conf = conf; this.contextInfoPromise = ctx; this.jobs = new ConcurrentHashMap<>(); this.protocol = new ClientProtocol(); this.driverRpc = ImmediateEventExecutor.INSTANCE.newPromise(); this.executorGroupId = EXECUTOR_GROUP_ID.incrementAndGet(); this.eventLoopGroup = new NioEventLoopGroup( conf.getInt(RPC_MAX_THREADS), Utils.newDaemonThreadFactory("RSCClient-" + executorGroupId + "-%d")); this.serverUriPromise = ImmediateEventExecutor.INSTANCE.newPromise(); Utils.addListener(this.contextInfoPromise, new FutureListener<ContextInfo>() { @Override public void onSuccess(ContextInfo info) throws Exception { connectToContext(info); String url = String.format("rsc://%s:%s@%s:%d", info.clientId, info.secret, info.remoteAddress, info.remotePort); serverUriPromise.setSuccess(URI.create(url)); } @Override public void onFailure(Throwable error) { connectionError(error); serverUriPromise.setFailure(error); } }); isAlive = true; }
cb.option(ChannelOption.AUTO_READ, autoRead); Promise<Void> serverDonePromise = ImmediateEventExecutor.INSTANCE.newPromise(); Promise<Void> clientDonePromise = ImmediateEventExecutor.INSTANCE.newPromise(); final StringEchoHandler sh = new StringEchoHandler(autoRead, serverDonePromise); final StringEchoHandler ch = new StringEchoHandler(autoRead, clientDonePromise);
/** * 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); }
public void testConnectNotExists(Bootstrap cb) throws Throwable { final Promise<Throwable> promise = ImmediateEventExecutor.INSTANCE.newPromise(); cb.handler(new ChannelInboundHandlerAdapter() { @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { promise.trySuccess(cause); } }); ChannelFuture future = cb.connect(NetUtil.LOCALHOST, SocketTestPermutation.BAD_PORT); try { Channel datagramChannel = future.syncUninterruptibly().channel(); Assert.assertTrue(datagramChannel.isActive()); datagramChannel.writeAndFlush( Unpooled.copiedBuffer("test", CharsetUtil.US_ASCII)).syncUninterruptibly(); if (!(datagramChannel instanceof OioDatagramChannel)) { Assert.assertTrue(promise.syncUninterruptibly().getNow() instanceof PortUnreachableException); } } finally { future.channel().close(); } } }
cb.option(ChannelOption.AUTO_READ, autoRead); Promise<Void> serverDonePromise = ImmediateEventExecutor.INSTANCE.newPromise(); final TestServerHandler sh = new TestServerHandler(autoRead, serverDonePromise, data.length); final TestHandler ch = new TestHandler(autoRead);
public void testLocalAddressAfterConnect(ServerBootstrap sb, Bootstrap cb) throws Throwable { Channel serverChannel = null; Channel clientChannel = null; try { final Promise<InetSocketAddress> localAddressPromise = ImmediateEventExecutor.INSTANCE.newPromise(); serverChannel = sb.childHandler(new ChannelInboundHandlerAdapter() { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { localAddressPromise.setSuccess((InetSocketAddress) ctx.channel().localAddress()); } }).bind().syncUninterruptibly().channel(); clientChannel = cb.handler(new ChannelInboundHandlerAdapter()).register().syncUninterruptibly().channel(); assertNull(clientChannel.localAddress()); assertNull(clientChannel.remoteAddress()); clientChannel.connect(serverChannel.localAddress()).syncUninterruptibly().channel(); assertLocalAddress((InetSocketAddress) clientChannel.localAddress()); assertNotNull(clientChannel.remoteAddress()); assertLocalAddress(localAddressPromise.get()); } finally { if (clientChannel != null) { clientChannel.close().syncUninterruptibly(); } if (serverChannel != null) { serverChannel.close().syncUninterruptibly(); } } }