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

List of usage examples for io.netty.util.concurrent Future isSuccess

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.util.concurrent.*
  5. Future
  6. 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:org.jboss.aerogear.webpush.netty.WebPushFrameListener.java

License:Apache License

private static void logFutureError(final Future future) {
    if (!future.isSuccess()) {
        LOGGER.error("ChannelFuture failed. Cause:", future.cause());
    }//  ww w .  j a  v a2s.c  o  m
}

From source file:org.jdiameter.client.impl.transport.tls.netty.StartTlsClientHandler.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//from  www  .ja  v a 2  s .  c  om
public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
    logger.debug("StartTlsClientHandler");
    ByteBuf buf = (ByteBuf) msg;
    byte[] bytes = new byte[buf.readableBytes()];
    buf.getBytes(buf.readerIndex(), bytes);

    if ("StartTlsResponse".equals(new String(bytes))) {
        logger.debug("received StartTlsResponse");

        SslContext sslContext = SslContextFactory.getSslContextForClient(this.tlsTransportClient.getConfig());
        SSLEngine sslEngine = sslContext.newEngine(ctx.alloc());
        sslEngine.setUseClientMode(true);
        SslHandler sslHandler = new SslHandler(sslEngine, false);

        final ChannelPipeline pipeline = ctx.pipeline();
        pipeline.remove("startTlsClientHandler");
        pipeline.addLast("sslHandler", sslHandler);

        logger.debug("StartTls starting handshake");

        sslHandler.handshakeFuture().addListener(new GenericFutureListener() {
            @Override
            public void operationComplete(Future future) throws Exception {
                if (future.isSuccess()) {
                    logger.debug("StartTls handshake succesfull");

                    tlsTransportClient.setTlsHandshakingState(TlsHandshakingState.SHAKEN);

                    logger.debug("restoring all handlers");

                    pipeline.addLast("decoder",
                            new DiameterMessageDecoder(
                                    StartTlsClientHandler.this.tlsTransportClient.getParent(),
                                    StartTlsClientHandler.this.tlsTransportClient.getParser()));
                    pipeline.addLast("msgHandler", new DiameterMessageHandler(
                            StartTlsClientHandler.this.tlsTransportClient.getParent(), true));

                    pipeline.addLast("encoder", new DiameterMessageEncoder(
                            StartTlsClientHandler.this.tlsTransportClient.getParser()));
                    pipeline.addLast("inbandWriter", new InbandSecurityHandler());
                }
            }
        });

    }
}

From source file:org.jdiameter.client.impl.transport.tls.netty.StartTlsInitiator.java

License:Open Source License

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override//from   ww  w  .ja v a2 s .  co  m
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    if (msg instanceof IMessage) {
        IMessage m = (IMessage) msg;
        logger.debug("StartTlsInitiator");
        if (m.getCommandCode() == IMessage.CAPABILITIES_EXCHANGE_ANSWER
                && this.tlsTransportClient.getTlsHandshakingState() == TlsHandshakingState.INIT) {
            AvpSet set = m.getAvps();
            Avp inbandAvp = set.getAvp(Avp.INBAND_SECURITY_ID);
            if (inbandAvp != null && inbandAvp.getUnsigned32() == 1) {
                this.tlsTransportClient.setTlsHandshakingState(TlsHandshakingState.SHAKING);

                final ChannelPipeline pipeline = ctx.pipeline();
                pipeline.remove("decoder");
                pipeline.remove("msgHandler");
                pipeline.remove(this);
                pipeline.remove("encoder");
                pipeline.remove("inbandWriter");

                pipeline.addLast("startTlsClientHandler", new StartTlsClientHandler(this.tlsTransportClient));

                logger.debug("Sending StartTlsRequest");
                ctx.writeAndFlush(Unpooled.wrappedBuffer("StartTlsRequest".getBytes()))
                        .addListener(new GenericFutureListener() {

                            @Override
                            public void operationComplete(Future f) throws Exception {
                                if (!f.isSuccess()) {
                                    logger.error(f.cause().getMessage(), f.cause());
                                }
                            }
                        });

            }
        }
    }

    ReferenceCountUtil.release(msg);
}

From source file:org.jdiameter.client.impl.transport.tls.netty.StartTlsServerHandler.java

License:Open Source License

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override/*from  w  ww.  ja v a2  s  .c  o  m*/
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    logger.debug("StartTlsServerHandler");
    ByteBuf buf = (ByteBuf) msg;
    byte[] bytes = new byte[buf.readableBytes()];
    buf.getBytes(buf.readerIndex(), bytes);

    if ("StartTlsRequest".equals(new String(bytes))) {
        logger.debug("Received StartTlsRequest");
        SslContext sslContext = SslContextFactory.getSslContextForServer(this.tlsTransportClient.getConfig());
        SSLEngine sslEngine = sslContext.newEngine(ctx.alloc());
        sslEngine.setUseClientMode(false);
        SslHandler sslHandler = new SslHandler(sslEngine, false);

        final ChannelPipeline pipeline = ctx.pipeline();

        pipeline.remove("decoder");
        pipeline.remove("msgHandler");
        pipeline.remove("encoder");
        pipeline.remove("inbandWriter");
        pipeline.remove(this);

        pipeline.addLast("sslHandler", sslHandler);

        sslHandler.handshakeFuture().addListener(new GenericFutureListener() {

            @Override
            public void operationComplete(Future future) throws Exception {
                if (future.isSuccess()) {
                    logger.debug("StartTls server handshake succesfull");

                    tlsTransportClient.setTlsHandshakingState(TlsHandshakingState.SHAKEN);

                    logger.debug("restoring all handlers");

                    pipeline.addLast("decoder",
                            new DiameterMessageDecoder(
                                    StartTlsServerHandler.this.tlsTransportClient.getParent(),
                                    StartTlsServerHandler.this.tlsTransportClient.getParser()));
                    pipeline.addLast("msgHandler", new DiameterMessageHandler(
                            StartTlsServerHandler.this.tlsTransportClient.getParent(), true));

                    pipeline.addLast("encoder", new DiameterMessageEncoder(
                            StartTlsServerHandler.this.tlsTransportClient.getParser()));
                    pipeline.addLast("inbandWriter", new InbandSecurityHandler());

                }
            }
        });

        ReferenceCountUtil.release(msg);
        logger.debug("Sending StartTlsResponse");
        ctx.writeAndFlush(Unpooled.wrappedBuffer("StartTlsResponse".getBytes()))
                .addListener(new GenericFutureListener() {

                    @Override
                    public void operationComplete(Future f) throws Exception {
                        if (!f.isSuccess()) {
                            logger.error(f.cause().getMessage(), f.cause());
                        }

                    }
                });
    } else {
        ctx.fireChannelRead(msg);
    }

}

From source file:org.kaaproject.kaa.server.transports.http.transport.netty.DefaultHandler.java

License:Apache License

@Override
protected void channelRead0(final ChannelHandlerContext ctx, final AbstractCommand msg) throws Exception {
    Callable<AbstractCommand> callable = msg;

    final Future<AbstractCommand> future = executor.submit(callable);

    future.addListener(new GenericFutureListener<Future<Object>>() {
        @Override/*from   w  w  w .  j  a va  2s  .co  m*/
        public void operationComplete(final Future<Object> future) throws Exception {
            LOG.trace("DefaultHandler().operationComplete...");
            if (future.isSuccess()) {
                ctx.writeAndFlush(future.get());
            } else {
                ctx.fireExceptionCaught(future.cause());
            }
        }
    });
}

From source file:org.kobeyoung81.socksproxy.SocksServerConnectHandler.java

License:Apache License

@Override
public void channelRead0(final ChannelHandlerContext ctx, final SocksCmdRequest request) throws Exception {
    Promise<Channel> promise = ctx.executor().newPromise();
    promise.addListener(new GenericFutureListener<Future<Channel>>() {
        @Override//from w  ww  .  j a  va  2  s . c om
        public void operationComplete(final Future<Channel> future) throws Exception {
            final Channel outboundChannel = future.getNow();
            if (future.isSuccess()) {
                ctx.channel().writeAndFlush(new SocksCmdResponse(SocksCmdStatus.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));
                            }
                        });
                //System.out.println(request.toString());
            } else {
                ctx.channel()
                        .writeAndFlush(new SocksCmdResponse(SocksCmdStatus.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));
    //System.out.println(request.host() +":"+ request.port());
    //SocksCmdRequest re = new SocksCmdRequest(request.cmdType(), request.addressType(), "192.168.87.103", 8080);
    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 SocksCmdResponse(SocksCmdStatus.FAILURE, request.addressType()));
                SocksServerUtils.closeOnFlush(ctx.channel());
            }
        }
    });
}

From source file:org.opendaylight.bgpcep.pcep.topology.provider.AbstractTopologySessionListener.java

License:Open Source License

protected final synchronized ListenableFuture<OperationResult> sendMessage(final Message message,
        final S requestId, final Metadata metadata) {
    final io.netty.util.concurrent.Future<Void> f = this.session.sendMessage(message);
    this.listenerState.updateStatefulSentMsg(message);
    final PCEPRequest req = new PCEPRequest(metadata);
    this.requests.put(requestId, req);
    final int rpcTimeout = serverSessionManager.getRpcTimeout();
    LOG.trace("RPC response timeout value is {} seconds", rpcTimeout);
    if (rpcTimeout > 0) {
        setupTimeoutHandler(requestId, req, rpcTimeout);
    }// w  w w .  j av a2  s.  co  m

    f.addListener(new FutureListener<Void>() {
        @Override
        public void operationComplete(final io.netty.util.concurrent.Future<Void> future) {
            if (!future.isSuccess()) {
                synchronized (AbstractTopologySessionListener.this) {
                    AbstractTopologySessionListener.this.requests.remove(requestId);
                }
                req.done(OperationResults.UNSENT);
                LOG.info("Failed to send request {}, instruction cancelled", requestId, future.cause());
            } else {
                req.sent();
                LOG.trace("Request {} sent to peer (object {})", requestId, req);
            }
        }
    });

    return req.getFuture();
}

From source file:org.opendaylight.controller.netconf.client.SimpleNetconfClientSessionListenerTest.java

License:Open Source License

@Test
public void testSessionDown() throws Exception {
    SimpleNetconfClientSessionListener simpleListener = new SimpleNetconfClientSessionListener();
    Future<NetconfMessage> promise = simpleListener.sendRequest(message);
    simpleListener.onSessionUp(clientSession);
    verify(channel, times(1)).writeAndFlush(anyObject());

    simpleListener.onSessionDown(clientSession, new Exception());
    assertFalse(promise.isSuccess());
}

From source file:org.opendaylight.controller.netconf.client.SimpleNetconfClientSessionListenerTest.java

License:Open Source License

@Test
public void testSendRequest() throws Exception {
    SimpleNetconfClientSessionListener simpleListener = new SimpleNetconfClientSessionListener();
    Future<NetconfMessage> promise = simpleListener.sendRequest(message);
    simpleListener.onSessionUp(clientSession);
    verify(channel, times(1)).writeAndFlush(anyObject());

    simpleListener.sendRequest(message);
    assertFalse(promise.isSuccess());
}

From source file:org.opendaylight.controller.netconf.client.SimpleNetconfClientSessionListenerTest.java

License:Open Source License

@Test
public void testOnMessage() throws Exception {
    SimpleNetconfClientSessionListener simpleListener = new SimpleNetconfClientSessionListener();
    Future<NetconfMessage> promise = simpleListener.sendRequest(message);
    simpleListener.onSessionUp(clientSession);
    verify(channel, times(1)).writeAndFlush(anyObject());

    simpleListener.onMessage(clientSession, message);
    assertTrue(promise.isSuccess());
}