Example usage for io.netty.util.concurrent Promise setSuccess

List of usage examples for io.netty.util.concurrent Promise setSuccess

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.util.concurrent.*
  5. Promise
  6. setSuccess

Introduction

In this page you can find the example usage for io.netty.util.concurrent Promise setSuccess.

Prototype

Promise<V> setSuccess(V result);

Source Link

Document

Marks this future as a success and notifies all listeners.

Usage

From source file:com.linecorp.armeria.common.RequestContextTest.java

License:Apache License

@Test
public void contextAwareEventExecutor() throws Exception {
    EventLoop eventLoop = new DefaultEventLoop();
    when(channel.eventLoop()).thenReturn(eventLoop);
    RequestContext context = createContext();
    Set<Integer> callbacksCalled = new ConcurrentHashSet<>();
    EventExecutor executor = context.contextAwareEventLoop();
    CountDownLatch latch = new CountDownLatch(18);
    executor.execute(() -> checkCallback(1, context, callbacksCalled, latch));
    executor.schedule(() -> checkCallback(2, context, callbacksCalled, latch), 0, TimeUnit.SECONDS);
    executor.schedule(() -> {/*from   w w w . ja v a 2  s  . co  m*/
        checkCallback(2, context, callbacksCalled, latch);
        return "success";
    }, 0, TimeUnit.SECONDS);
    executor.scheduleAtFixedRate(() -> checkCallback(3, context, callbacksCalled, latch), 0, 1000,
            TimeUnit.SECONDS);
    executor.scheduleWithFixedDelay(() -> checkCallback(4, context, callbacksCalled, latch), 0, 1000,
            TimeUnit.SECONDS);
    executor.submit(() -> checkCallback(5, context, callbacksCalled, latch));
    executor.submit(() -> checkCallback(6, context, callbacksCalled, latch), "success");
    executor.submit(() -> {
        checkCallback(7, context, callbacksCalled, latch);
        return "success";
    });
    executor.invokeAll(makeTaskList(8, 10, context, callbacksCalled, latch));
    executor.invokeAll(makeTaskList(11, 12, context, callbacksCalled, latch), 10000, TimeUnit.SECONDS);
    executor.invokeAny(makeTaskList(13, 13, context, callbacksCalled, latch));
    executor.invokeAny(makeTaskList(14, 14, context, callbacksCalled, latch), 10000, TimeUnit.SECONDS);
    Promise<String> promise = executor.newPromise();
    promise.addListener(f -> checkCallback(15, context, callbacksCalled, latch));
    promise.setSuccess("success");
    executor.newSucceededFuture("success").addListener(f -> checkCallback(16, context, callbacksCalled, latch));
    executor.newFailedFuture(new IllegalArgumentException())
            .addListener(f -> checkCallback(17, context, callbacksCalled, latch));
    ProgressivePromise<String> progressivePromise = executor.newProgressivePromise();
    progressivePromise.addListener(f -> checkCallback(18, context, callbacksCalled, latch));
    progressivePromise.setSuccess("success");
    latch.await();
    eventLoop.shutdownGracefully().sync();
    assertEquals(IntStream.rangeClosed(1, 18).boxed().collect(Collectors.toSet()), callbacksCalled);
}

From source file:com.linecorp.armeria.common.RequestContextTest.java

License:Apache License

@Test
@SuppressWarnings("deprecation")
public void makeContextAwareFutureListener() {
    RequestContext context = createContext();
    Promise<String> promise = new DefaultPromise<>(ImmediateEventExecutor.INSTANCE);
    promise.addListener(context.makeContextAware((FutureListener<String>) f -> {
        assertEquals(context, RequestContext.current());
        assertTrue(entered.get());//from   ww w  .  j  av a 2 s  .  c om
    }));
    promise.setSuccess("success");
}

From source file:com.linkedin.mitm.proxy.channel.ChannelMediator.java

License:Open Source License

private void closeChannel(final Promise<Void> promise, final Channel channel) {
    channel.close().addListener(future -> {
        if (future.isSuccess()) {
            promise.setSuccess(null);
        } else {/*  w  ww.ja  v a  2 s. c o  m*/
            promise.setFailure(future.cause());
        }
    });
}

From source file:com.twitter.http2.Pipe.java

License:Apache License

/**
 * Sends a message to this pipe. Returns a {@link Future} that is completed
 * when the message is received.//from w w  w  .  j  a  v a 2s .  c o  m
 * <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;
}

From source file:com.zextras.modules.chat.server.xmpp.netty.TransparentProxy.java

License:Open Source License

public Future<Channel> connect() {
    final Promise<Channel> channelFuture = new DefaultProgressivePromise<Channel>(
            ImmediateEventExecutor.INSTANCE);

    if (mServerChannel == null) {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(mNettyService.getEventLoopGroup()).channel(NioSocketChannel.class)
                .remoteAddress(new InetSocketAddress(mAccount.getMailHost(), mPort)).handler(new Initializer());

        ChannelFuture serverChannelFuture = bootstrap.connect();
        serverChannelFuture.addListener(new ChannelFutureListener() {
            @Override/*from w  w w .  j av  a2  s  .  c  om*/
            public void operationComplete(ChannelFuture future) {
                if (future.isSuccess()) {
                    ChatLog.log.info(
                            "Proxy xmpp requests for " + mAccount.getName() + " to " + mAccount.getMailHost());
                    mServerChannel = future.channel();

                    mServerChannel.write(Unpooled.wrappedBuffer(mStreamInit.getBytes()));
                    mServerChannel.writeAndFlush(Unpooled.wrappedBuffer(mInitialPayload.getBytes()));

                    mServerChannel.pipeline().addLast("proxyToClient", new Proxy(mClientChannel));

                    mClientChannel.pipeline().addLast("proxyToServer", new Proxy(mServerChannel));

                    mServerChannel.closeFuture().addListener(new ChannelFutureListener() {
                        @Override
                        public void operationComplete(ChannelFuture future) throws Exception {
                            mClientChannel.close();
                        }
                    });

                    mClientChannel.closeFuture().addListener(new ChannelFutureListener() {
                        @Override
                        public void operationComplete(ChannelFuture future) throws Exception {
                            mServerChannel.close();
                        }
                    });

                    future.channel().closeFuture();

                    channelFuture.setSuccess(mServerChannel);
                } else {
                    ChatLog.log.info("Cannot proxy xmpp requests for " + mAccount.getName() + " to "
                            + mAccount.getMailHost() + ": " + Utils.exceptionToString(future.cause()));
                    sendInternalError(mClientChannel);
                    mClientChannel.flush().close();
                    channelFuture.setFailure(future.cause());
                }
            }
        });

        return channelFuture;
    } else {
        mServerChannel.pipeline().addLast("proxyToClient", new Proxy(mClientChannel));

        mServerChannel.writeAndFlush(mInitialPayload.getBytes());

        channelFuture.setSuccess(mServerChannel);
        return channelFuture;
    }
}

From source file:io.gatling.http.client.impl.DefaultHttpClient.java

License:Apache License

private Future<List<InetSocketAddress>> resolveRemoteAddresses(Request request, EventLoop eventLoop,
        HttpListener listener, RequestTimeout requestTimeout) {
    if (!request.getUri().isSecured() && request.getProxyServer() instanceof HttpProxyServer) {
        // directly connect to proxy over clear HTTP
        InetSocketAddress remoteAddress = ((HttpProxyServer) request.getProxyServer()).getAddress();
        return ImmediateEventExecutor.INSTANCE.newSucceededFuture(singletonList(remoteAddress));
    } else {//  w  ww  . j a va 2s  .com
        Promise<List<InetSocketAddress>> p = eventLoop.newPromise();

        request.getNameResolver().resolveAll(request.getUri().getHost(), eventLoop.newPromise())
                .addListener((Future<List<InetAddress>> whenAddresses) -> {
                    if (whenAddresses.isSuccess()) {
                        List<InetSocketAddress> remoteInetSocketAddresses = whenAddresses.getNow().stream().map(
                                address -> new InetSocketAddress(address, request.getUri().getExplicitPort()))
                                .collect(Collectors.toList());

                        p.setSuccess(remoteInetSocketAddresses);
                    } else {
                        if (!requestTimeout.isDone()) {
                            // only report if we haven't timed out
                            listener.onThrowable(whenAddresses.cause());
                        }
                        p.setFailure(whenAddresses.cause());
                    }
                });
        return p;
    }
}

From source file:io.gatling.http.client.impl.DefaultHttpClient.java

License:Apache License

private void openNewChannelRec(List<InetSocketAddress> remoteAddresses, InetSocketAddress localAddress, int i,
        Promise<Channel> channelPromise, Bootstrap bootstrap, HttpListener listener,
        RequestTimeout requestTimeout) {

    if (isClosed()) {
        return;//from   w  w w .j  a  va 2s.  co m
    }

    InetSocketAddress remoteAddress = remoteAddresses.get(i);

    listener.onTcpConnectAttempt(remoteAddress);
    ChannelFuture whenChannel = bootstrap.connect(remoteAddress, localAddress);

    whenChannel.addListener(f -> {
        if (f.isSuccess()) {
            Channel channel = whenChannel.channel();
            listener.onTcpConnectSuccess(remoteAddress, channel);
            channelPromise.setSuccess(channel);

        } else {
            listener.onTcpConnectFailure(remoteAddress, f.cause());

            if (requestTimeout.isDone()) {
                channelPromise.setFailure(IGNORE_REQUEST_TIMEOUT_REACHED_WHILE_TRYING_TO_CONNECT);
                return;
            }

            int nextI = i + 1;
            if (nextI < remoteAddresses.size()) {
                openNewChannelRec(remoteAddresses, localAddress, nextI, channelPromise, bootstrap, listener,
                        requestTimeout);

            } else {
                requestTimeout.cancel();
                listener.onThrowable(f.cause());
                channelPromise.setFailure(f.cause());
            }
        }
    });
}

From source file:io.gatling.http.client.impl.DefaultHttpClient.java

License:Apache License

private Future<Channel> installHttp2Handler(HttpTx tx, Channel channel, ChannelPool channelPool) {

    Promise<Channel> whenAlpn = channel.eventLoop().newPromise();

    channel.pipeline().addAfter(SSL_HANDLER, ALPN_HANDLER,
            new ApplicationProtocolNegotiationHandler(ApplicationProtocolNames.HTTP_1_1) {
                @Override//from   w  ww  .j  a va 2  s.c  o m
                protected void configurePipeline(ChannelHandlerContext ctx, String protocol) throws Exception {

                    switch (protocol) {
                    case ApplicationProtocolNames.HTTP_2:
                        LOGGER.debug("ALPN led to HTTP/2 with remote {}", tx.request.getUri().getHost());
                        tx.listener.onProtocolAwareness(true);
                        Http2Connection connection = new DefaultHttp2Connection(false);

                        HttpToHttp2ConnectionHandler http2Handler = new HttpToHttp2ConnectionHandlerBuilder()
                                .initialSettings(Http2Settings.defaultSettings()) // FIXME override?
                                .connection(connection)
                                .frameListener(new DelegatingDecompressorFrameListener(connection,
                                        new ChunkedInboundHttp2ToHttpAdapter(connection, false, true,
                                                whenAlpn)))
                                .build();

                        ctx.pipeline().addLast(HTTP2_HANDLER, http2Handler).addLast(APP_HTTP2_HANDLER,
                                new Http2AppHandler(connection, http2Handler, channelPool, config));

                        channelPool.offer(channel);

                        SslHandler sslHandler = (SslHandler) ctx.pipeline().get(SSL_HANDLER);
                        Set<String> subjectAlternativeNames = Tls
                                .extractSubjectAlternativeNames(sslHandler.engine());
                        if (!subjectAlternativeNames.isEmpty()) {
                            channelPool.addCoalescedChannel(subjectAlternativeNames,
                                    (InetSocketAddress) channel.remoteAddress(), channel, tx.key);
                        }
                        break;

                    case ApplicationProtocolNames.HTTP_1_1:
                        LOGGER.debug("ALPN led to HTTP/1 with remote {}", tx.request.getUri().getHost());
                        if (tx.request.isHttp2PriorKnowledge()) {
                            IllegalStateException e = new IllegalStateException(
                                    "HTTP/2 Prior knowledge was set on host " + tx.request.getUri().getHost()
                                            + " but it only supports HTTP/1");
                            whenAlpn.setFailure(e);
                            throw e;
                        }
                        tx.listener.onProtocolAwareness(false);
                        ctx.pipeline()
                                .addBefore(CHUNKED_WRITER_HANDLER, HTTP_CLIENT_CODEC, newHttpClientCodec())
                                .addBefore(CHUNKED_WRITER_HANDLER, INFLATER_HANDLER,
                                        newHttpContentDecompressor())
                                .addAfter(CHUNKED_WRITER_HANDLER, APP_HTTP_HANDLER,
                                        new HttpAppHandler(DefaultHttpClient.this, channelPool, config));
                        whenAlpn.setSuccess(ctx.channel());
                        break;

                    default:
                        IllegalStateException e = new IllegalStateException("Unknown protocol: " + protocol);
                        whenAlpn.setFailure(e);
                        ctx.close();
                        // FIXME do we really need to throw?
                        throw e;
                    }
                }
            });

    whenAlpn.addListener(f -> {
        if (!f.isSuccess()) {
            tx.listener.onThrowable(f.cause());
        }
    });

    return whenAlpn;
}

From source file:io.vertx.core.dns.impl.fix.DnsNameResolver.java

License:Apache License

/**
 * Hook designed for extensibility so one can pass a different cache on each resolution attempt
 * instead of using the global one./*w ww  .  j  a va 2  s  . c om*/
 */
protected void doResolve(String inetHost, Promise<InetAddress> promise, DnsCache resolveCache)
        throws Exception {
    final byte[] bytes = NetUtil.createByteArrayFromIpAddressString(inetHost);
    if (bytes != null) {
        // The inetHost is actually an ipaddress.
        promise.setSuccess(InetAddress.getByAddress(bytes));
        return;
    }

    final String hostname = hostname(inetHost);

    InetAddress hostsFileEntry = resolveHostsFileEntry(hostname);
    if (hostsFileEntry != null) {
        promise.setSuccess(hostsFileEntry);
        return;
    }

    if (!doResolveCached(hostname, promise, resolveCache)) {
        doResolveUncached(hostname, promise, resolveCache);
    }
}

From source file:io.vertx.core.dns.impl.fix.DnsNameResolver.java

License:Apache License

private void doResolveUncached(String hostname, Promise<InetAddress> promise, DnsCache resolveCache,
        boolean trySearchDomain) {
    if (trySearchDomain) {
        Promise<InetAddress> original = promise;
        promise = new DefaultPromise<>(executor());
        FutureListener<InetAddress> globalListener = future -> {
            if (future.isSuccess()) {
                original.setSuccess(future.getNow());
            } else {
                FutureListener<InetAddress> sdListener = new FutureListener<InetAddress>() {
                    int count;

                    @Override/*ww  w . j av a 2  s .c  om*/
                    public void operationComplete(Future<InetAddress> future) throws Exception {
                        if (future.isSuccess()) {
                            original.trySuccess(future.getNow());
                        } else {
                            if (count < searchDomains.size()) {
                                String searchDomain = searchDomains.get(count++);
                                Promise<InetAddress> p = new DefaultPromise<>(executor());
                                doResolveUncached(hostname + "." + searchDomain, p, resolveCache, false);
                                p.addListener(this);
                            } else {
                                original.tryFailure(future.cause());
                            }
                        }
                    }
                };
                future.addListener(sdListener);
            }
        };
        promise.addListener(globalListener);
    }
    if (searchDomains(hostname)) {
        promise.tryFailure(new UnknownHostException(hostname));
    } else {
        final DnsNameResolverContext<InetAddress> ctx = new DnsNameResolverContext<InetAddress>(this, hostname,
                promise, resolveCache) {
            @Override
            protected boolean finishResolve(Class<? extends InetAddress> addressType,
                    List<DnsCacheEntry> resolvedEntries) {

                final int numEntries = resolvedEntries.size();
                for (int i = 0; i < numEntries; i++) {
                    final InetAddress a = resolvedEntries.get(i).address();
                    if (addressType.isInstance(a)) {
                        setSuccess(promise(), a);
                        return true;
                    }
                }
                return false;
            }
        };

        ctx.resolve();
    }
}