Example usage for io.netty.util.concurrent Future isSuccess

Introduction

In this page you can find the example usage for io.netty.util.concurrent Future isSuccess.

Prototype

boolean isSuccess();

Source Link

Document

Returns true if and only if the I/O operation was completed successfully.

Usage

From source file:io.advantageous.conekt.impl.ConektImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
private void deleteCacheDirAndShutdown(Handler<AsyncResult<Void>> completionHandler) {
    fileResolver.close(res -> {//  w w w  .j av a 2s.com

        workerPool.shutdownNow();
        internalBlockingPool.shutdownNow();

        acceptorEventLoopGroup.shutdownGracefully(0, 10, TimeUnit.SECONDS)
                .addListener(new GenericFutureListener() {
                    @Override
                    public void operationComplete(io.netty.util.concurrent.Future future) throws Exception {
                        if (!future.isSuccess()) {
                            log.warn("Failure in shutting down acceptor event loop group", future.cause());
                        }
                        eventLoopGroup.shutdownGracefully(0, 10, TimeUnit.SECONDS)
                                .addListener(new GenericFutureListener() {
                                    @Override
                                    public void operationComplete(io.netty.util.concurrent.Future future)
                                            throws Exception {
                                        if (!future.isSuccess()) {
                                            log.warn("Failure in shutting down event loop group",
                                                    future.cause());
                                        }
                                        if (metrics != null) {
                                            metrics.close();
                                        }

                                        checker.close();

                                        if (completionHandler != null) {
                                            eventLoopThreadFactory.newThread(() -> {
                                                completionHandler.handle(
                                                        io.advantageous.conekt.Future.succeededFuture());
                                            }).start();
                                        }
                                    }
                                });
                    }
                });
    });
}

From source file:io.airlift.drift.transport.netty.client.ConnectionPool.java

License:Apache License

private Future<Channel> createConnection(ConnectionKey key) {
    Future<Channel> future = connectionFactory.getConnection(key.getConnectionParameters(), key.getAddress());

    // remove connection from cache when it is closed
    future.addListener(channelFuture -> {
        if (future.isSuccess()) {
            future.getNow().closeFuture()
                    .addListener(closeFuture -> cachedConnections.asMap().remove(key, future));
        }//w ww. j ava 2  s  . c  o m
    });

    return future;
}

From source file:io.airlift.drift.transport.netty.client.ConnectionPool.java

License:Apache License

private static void closeConnection(Future<Channel> future) {
    future.addListener(ignored -> {//from   w w w  .  ja  va 2 s . c  o m
        if (future.isSuccess()) {
            Channel channel = future.getNow();
            channel.close();
        }
    });
}

From source file:io.airlift.drift.transport.netty.client.TestConnectionPool.java

License:Apache License

private static <T> T futureGet(Future<T> future) {
    assertTrue(future.isSuccess());
    return future.getNow();
}

From source file:io.aos.netty5.socksproxy.SocksServerConnectHandler.java

License:Apache License

@Override
public void messageReceived(final ChannelHandlerContext ctx, final SocksRequest message) throws Exception {
    if (message instanceof Socks4CmdRequest) {
        final Socks4CmdRequest request = (Socks4CmdRequest) message;
        Promise<Channel> promise = ctx.executor().newPromise();
        promise.addListener(new GenericFutureListener<Future<Channel>>() {
            @Override/* w  w w.  j a  va2  s.c o  m*/
            public void operationComplete(final Future<Channel> future) throws Exception {
                final Channel outboundChannel = future.getNow();
                if (future.isSuccess()) {
                    ctx.channel().writeAndFlush(new Socks4CmdResponse(Socks4CmdStatus.SUCCESS))
                            .addListener(new ChannelFutureListener() {
                                @Override
                                public void operationComplete(ChannelFuture channelFuture) {
                                    ctx.pipeline().remove(SocksServerConnectHandler.this);
                                    outboundChannel.pipeline().addLast(new RelayHandler(ctx.channel()));
                                    ctx.pipeline().addLast(new RelayHandler(outboundChannel));
                                }
                            });
                } else {
                    ctx.channel().writeAndFlush(new Socks4CmdResponse(Socks4CmdStatus.REJECTED_OR_FAILED));
                    SocksServerUtils.closeOnFlush(ctx.channel());
                }
            }
        });

        final Channel inboundChannel = ctx.channel();
        b.group(inboundChannel.eventLoop()).channel(NioSocketChannel.class)
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000).option(ChannelOption.SO_KEEPALIVE, true)
                .handler(new DirectClientHandler(promise));

        b.connect(request.host(), request.port()).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    // Connection established use handler provided results
                } else {
                    // Close the connection if the connection attempt has failed.
                    ctx.channel().writeAndFlush(new Socks4CmdResponse(Socks4CmdStatus.REJECTED_OR_FAILED));
                    SocksServerUtils.closeOnFlush(ctx.channel());
                }
            }
        });
    } else if (message instanceof Socks5CmdRequest) {
        final Socks5CmdRequest request = (Socks5CmdRequest) message;
        Promise<Channel> promise = ctx.executor().newPromise();
        promise.addListener(new GenericFutureListener<Future<Channel>>() {
            @Override
            public void operationComplete(final Future<Channel> future) throws Exception {
                final Channel outboundChannel = future.getNow();
                if (future.isSuccess()) {
                    ctx.channel()
                            .writeAndFlush(
                                    new Socks5CmdResponse(Socks5CmdStatus.SUCCESS, request.addressType()))
                            .addListener(new ChannelFutureListener() {
                                @Override
                                public void operationComplete(ChannelFuture channelFuture) {
                                    ctx.pipeline().remove(SocksServerConnectHandler.this);
                                    outboundChannel.pipeline().addLast(new RelayHandler(ctx.channel()));
                                    ctx.pipeline().addLast(new RelayHandler(outboundChannel));
                                }
                            });
                } else {
                    ctx.channel().writeAndFlush(
                            new Socks5CmdResponse(Socks5CmdStatus.FAILURE, request.addressType()));
                    SocksServerUtils.closeOnFlush(ctx.channel());
                }
            }
        });

        final Channel inboundChannel = ctx.channel();
        b.group(inboundChannel.eventLoop()).channel(NioSocketChannel.class)
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000).option(ChannelOption.SO_KEEPALIVE, true)
                .handler(new DirectClientHandler(promise));

        b.connect(request.host(), request.port()).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    // Connection established use handler provided results
                } else {
                    // Close the connection if the connection attempt has failed.
                    ctx.channel().writeAndFlush(
                            new Socks5CmdResponse(Socks5CmdStatus.FAILURE, request.addressType()));
                    SocksServerUtils.closeOnFlush(ctx.channel());
                }
            }
        });
    } else {
        ctx.close();
    }
}

From source file:io.codis.nedis.NedisClientPoolImpl.java

License:Apache License

private Future<NedisClient> newClient() {
    Future<NedisClientImpl> f = NedisClientBuilder.create().group(group).channel(channelClass)
            .timeoutMs(timeoutMs).belongTo(this).connect(remoteAddress);

    final Promise<NedisClient> promise = getEventExecutor(f).newPromise();
    f.addListener(new FutureListener<NedisClientImpl>() {

        @Override/*  w w w .j  av a  2 s .  c o m*/
        public void operationComplete(Future<NedisClientImpl> future) throws Exception {
            if (future.isSuccess()) {
                initialize(promise, future.getNow(), State.AUTH);
            } else {
                promise.tryFailure(future.cause());
            }
        }

    });
    return promise;
}

From source file:io.codis.nedis.PromiseConverter.java

License:Apache License

public static PromiseConverter<List<byte[]>> toList(EventExecutor executor) {
    return new PromiseConverter<List<byte[]>>(executor) {

        @Override//from w  w w  . j av  a  2  s.co m
        public FutureListener<Object> newListener(final Promise<List<byte[]>> promise) {
            return new FutureListener<Object>() {

                @SuppressWarnings("unchecked")
                @Override
                public void operationComplete(Future<Object> future) throws Exception {
                    if (future.isSuccess()) {
                        Object resp = future.getNow();
                        if (resp instanceof RedisResponseException) {
                            promise.tryFailure((RedisResponseException) resp);
                        } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                            promise.trySuccess(null);
                        } else {
                            promise.trySuccess((List<byte[]>) resp);
                        }
                    } else {
                        promise.tryFailure(future.cause());
                    }
                }
            };
        }
    };
}

From source file:io.codis.nedis.PromiseConverter.java

License:Apache License

public static PromiseConverter<Boolean> toBoolean(EventExecutor executor) {
    return new PromiseConverter<Boolean>(executor) {

        @Override/*from   w  w w  .  j ava  2  s. co  m*/
        public FutureListener<Object> newListener(final Promise<Boolean> promise) {
            return new FutureListener<Object>() {

                @Override
                public void operationComplete(Future<Object> future) throws Exception {
                    if (future.isSuccess()) {
                        Object resp = future.getNow();
                        if (resp instanceof RedisResponseException) {
                            promise.tryFailure((RedisResponseException) resp);
                        } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                            promise.trySuccess(false);
                        } else if (resp instanceof String) {
                            promise.trySuccess(true);
                        } else {
                            promise.trySuccess(((Long) resp).intValue() != 0);
                        }
                    } else {
                        promise.tryFailure(future.cause());
                    }
                }
            };
        }
    };
}

From source file:io.codis.nedis.PromiseConverter.java

License:Apache License

public static PromiseConverter<byte[]> toBytes(EventExecutor executor) {
    return new PromiseConverter<byte[]>(executor) {

        @Override//  www .  j a v  a2  s.c o  m
        public FutureListener<Object> newListener(final Promise<byte[]> promise) {
            return new FutureListener<Object>() {

                @Override
                public void operationComplete(Future<Object> future) throws Exception {
                    if (future.isSuccess()) {
                        Object resp = future.getNow();
                        if (resp instanceof RedisResponseException) {
                            promise.tryFailure((RedisResponseException) resp);
                        } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                            promise.trySuccess(null);
                        } else {
                            promise.trySuccess((byte[]) resp);
                        }
                    } else {
                        promise.tryFailure(future.cause());
                    }
                }
            };
        }
    };
}

From source file:io.codis.nedis.PromiseConverter.java

License:Apache License

public static PromiseConverter<Double> toDouble(EventExecutor executor) {
    return new PromiseConverter<Double>(executor) {

        @Override/*  w ww.  j av a  2  s .c o  m*/
        public FutureListener<Object> newListener(final Promise<Double> promise) {
            return new FutureListener<Object>() {

                @Override
                public void operationComplete(Future<Object> future) throws Exception {
                    if (future.isSuccess()) {
                        Object resp = future.getNow();
                        if (resp instanceof RedisResponseException) {
                            promise.tryFailure((RedisResponseException) resp);
                        } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                            promise.trySuccess(null);
                        } else {
                            promise.trySuccess(bytesToDouble((byte[]) resp));
                        }
                    } else {
                        promise.tryFailure(future.cause());
                    }
                }
            };
        }
    };
}