Examples with ChannelInitializer org.apache.flink.shaded.netty4.io.netty.channel.ChannelInitializer used on opensource projects

Example 21 with ChannelInitializer

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInitializer in project cassandra by apache.

the class ProxyHandlerTest method test.

public void test(DoTest test) throws Throwable {
    EventLoopGroup serverGroup = new NioEventLoopGroup(1);
    EventLoopGroup clientGroup = new NioEventLoopGroup(1);
    InboundProxyHandler.Controller controller = new InboundProxyHandler.Controller();
    InboundProxyHandler proxyHandler = new InboundProxyHandler(controller);
    TestHandler testHandler = new TestHandler();
    ServerBootstrap sb = new ServerBootstrap();
    sb.group(serverGroup).channel(LocalServerChannel.class).childHandler(new ChannelInitializer<LocalChannel>() {

        @Override
        public void initChannel(LocalChannel ch) {
            ch.pipeline().addLast(proxyHandler).addLast(testHandler);
        }
    }).childOption(ChannelOption.AUTO_READ, false);
    Bootstrap cb = new Bootstrap();
    cb.group(clientGroup).channel(LocalChannel.class).handler(new ChannelInitializer<LocalChannel>() {

        @Override
        public void initChannel(LocalChannel ch) throws Exception {
            ch.pipeline().addLast(new LoggingHandler(LogLevel.TRACE));
        }
    });
    final LocalAddress addr = new LocalAddress("test");
    Channel serverChannel = sb.bind(addr).sync().channel();
    Channel clientChannel = cb.connect(addr).sync().channel();
    test.doTest(controller, testHandler, clientChannel);
    clientChannel.close();
    serverChannel.close();
    serverGroup.shutdownGracefully();
    clientGroup.shutdownGracefully();
}

Example 22 with ChannelInitializer

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInitializer in project flink by apache.

the class NettyClient method connect.

// ------------------------------------------------------------------------
// Client connections
// ------------------------------------------------------------------------
ChannelFuture connect(final InetSocketAddress serverSocketAddress) {
    checkState(bootstrap != null, "Client has not been initialized yet.");
    // --------------------------------------------------------------------
    // Child channel pipeline for accepted connections
    // --------------------------------------------------------------------
    bootstrap.handler(new ChannelInitializer<SocketChannel>() {

        @Override
        public void initChannel(SocketChannel channel) throws Exception {
            // SSL handler should be added first in the pipeline
            if (clientSSLFactory != null) {
                SslHandler sslHandler = clientSSLFactory.createNettySSLHandler(channel.alloc(), serverSocketAddress.getAddress().getCanonicalHostName(), serverSocketAddress.getPort());
                channel.pipeline().addLast("ssl", sslHandler);
            }
            channel.pipeline().addLast(protocol.getClientChannelHandlers());
        }
    });
    try {
        return bootstrap.connect(serverSocketAddress);
    } catch (ChannelException e) {
        if ((e.getCause() instanceof java.net.SocketException && e.getCause().getMessage().equals("Too many open files")) || (e.getCause() instanceof ChannelException && e.getCause().getCause() instanceof java.net.SocketException && e.getCause().getCause().getMessage().equals("Too many open files"))) {
            throw new ChannelException("The operating system does not offer enough file handles to open the network connection. " + "Please increase the number of available file handles.", e.getCause());
        } else {
            throw e;
        }
    }
}

Example 23 with ChannelInitializer

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInitializer in project netty by netty.

the class SslHandlerTest method testHandshakeFailureOnlyFireExceptionOnce.

@Test
@Timeout(value = 10000, unit = TimeUnit.MILLISECONDS)
public void testHandshakeFailureOnlyFireExceptionOnce() throws Exception {
    final SslContext sslClientCtx = SslContextBuilder.forClient().trustManager(new X509ExtendedTrustManager() {

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket) throws CertificateException {
            failVerification();
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket) throws CertificateException {
            failVerification();
        }

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine) throws CertificateException {
            failVerification();
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine) throws CertificateException {
            failVerification();
        }

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            failVerification();
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            failVerification();
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return EmptyArrays.EMPTY_X509_CERTIFICATES;
        }

        private void failVerification() throws CertificateException {
            throw new CertificateException();
        }
    }).sslProvider(SslProvider.JDK).build();
    final SelfSignedCertificate cert = new SelfSignedCertificate();
    final SslContext sslServerCtx = SslContextBuilder.forServer(cert.key(), cert.cert()).sslProvider(SslProvider.JDK).build();
    EventLoopGroup group = new NioEventLoopGroup();
    Channel sc = null;
    final SslHandler clientSslHandler = sslClientCtx.newHandler(UnpooledByteBufAllocator.DEFAULT);
    final SslHandler serverSslHandler = sslServerCtx.newHandler(UnpooledByteBufAllocator.DEFAULT);
    try {
        final Object terminalEvent = new Object();
        final BlockingQueue<Object> errorQueue = new LinkedBlockingQueue<Object>();
        sc = new ServerBootstrap().group(group).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) {
                ch.pipeline().addLast(serverSslHandler);
                ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {

                    @Override
                    public void exceptionCaught(final ChannelHandlerContext ctx, Throwable cause) {
                        errorQueue.add(cause);
                    }

                    @Override
                    public void channelInactive(ChannelHandlerContext ctx) {
                        errorQueue.add(terminalEvent);
                    }
                });
            }
        }).bind(new InetSocketAddress(0)).syncUninterruptibly().channel();
        final ChannelFuture future = new Bootstrap().group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) {
                ch.pipeline().addLast(clientSslHandler);
            }
        }).connect(sc.localAddress());
        future.syncUninterruptibly();
        clientSslHandler.handshakeFuture().addListener(new FutureListener<Channel>() {

            @Override
            public void operationComplete(Future<Channel> f) {
                future.channel().close();
            }
        });
        assertFalse(clientSslHandler.handshakeFuture().await().isSuccess());
        assertFalse(serverSslHandler.handshakeFuture().await().isSuccess());
        Object error = errorQueue.take();
        assertThat(error, Matchers.instanceOf(DecoderException.class));
        assertThat(((Throwable) error).getCause(), Matchers.<Throwable>instanceOf(SSLException.class));
        Object terminal = errorQueue.take();
        assertSame(terminalEvent, terminal);
        assertNull(errorQueue.poll(1, TimeUnit.MILLISECONDS));
    } finally {
        if (sc != null) {
            sc.close().syncUninterruptibly();
        }
        group.shutdownGracefully();
    }
}

Example 24 with ChannelInitializer

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInitializer in project netty by netty.

the class SslHandlerTest method newHandler.

private static ChannelHandler newHandler(final SslContext sslCtx, final Promise<Void> promise) {
    return new ChannelInitializer() {

        @Override
        protected void initChannel(final Channel ch) {
            final SslHandler sslHandler = sslCtx.newHandler(ch.alloc());
            sslHandler.setHandshakeTimeoutMillis(1000);
            ch.pipeline().addFirst(sslHandler);
            sslHandler.handshakeFuture().addListener(new FutureListener<Channel>() {

                @Override
                public void operationComplete(final Future<Channel> future) {
                    ch.pipeline().remove(sslHandler);
                    // Schedule the close so removal has time to propagate exception if any.
                    ch.eventLoop().execute(new Runnable() {

                        @Override
                        public void run() {
                            ch.close();
                        }
                    });
                }
            });
            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {

                @Override
                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
                    if (cause instanceof CodecException) {
                        cause = cause.getCause();
                    }
                    if (cause instanceof IllegalReferenceCountException) {
                        promise.setFailure(cause);
                    }
                }

                @Override
                public void channelInactive(ChannelHandlerContext ctx) {
                    promise.trySuccess(null);
                }
            });
        }
    };
}

Example 25 with ChannelInitializer

use of org.apache.flink.shaded.netty4.io.netty.channel.ChannelInitializer in project netty by netty.

the class SslHandlerTest method testHandshakeFailureCipherMissmatch.

private static void testHandshakeFailureCipherMissmatch(SslProvider provider, boolean tls13) throws Exception {
    final String clientCipher;
    final String serverCipher;
    final String protocol;
    if (tls13) {
        clientCipher = "TLS_AES_128_GCM_SHA256";
        serverCipher = "TLS_AES_256_GCM_SHA384";
        protocol = SslProtocols.TLS_v1_3;
    } else {
        clientCipher = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256";
        serverCipher = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384";
        protocol = SslProtocols.TLS_v1_2;
    }
    final SslContext sslClientCtx = SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).protocols(protocol).ciphers(Collections.singleton(clientCipher)).sslProvider(provider).build();
    final SelfSignedCertificate cert = new SelfSignedCertificate();
    final SslContext sslServerCtx = SslContextBuilder.forServer(cert.key(), cert.cert()).protocols(protocol).ciphers(Collections.singleton(serverCipher)).sslProvider(provider).build();
    EventLoopGroup group = new NioEventLoopGroup();
    Channel sc = null;
    Channel cc = null;
    final SslHandler clientSslHandler = sslClientCtx.newHandler(UnpooledByteBufAllocator.DEFAULT);
    final SslHandler serverSslHandler = sslServerCtx.newHandler(UnpooledByteBufAllocator.DEFAULT);
    class SslEventHandler extends ChannelInboundHandlerAdapter {

        private final AtomicReference<SslHandshakeCompletionEvent> ref;

        SslEventHandler(AtomicReference<SslHandshakeCompletionEvent> ref) {
            this.ref = ref;
        }

        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
            if (evt instanceof SslHandshakeCompletionEvent) {
                ref.set((SslHandshakeCompletionEvent) evt);
            }
            super.userEventTriggered(ctx, evt);
        }
    }
    final AtomicReference<SslHandshakeCompletionEvent> clientEvent = new AtomicReference<SslHandshakeCompletionEvent>();
    final AtomicReference<SslHandshakeCompletionEvent> serverEvent = new AtomicReference<SslHandshakeCompletionEvent>();
    try {
        sc = new ServerBootstrap().group(group).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) throws Exception {
                ch.pipeline().addLast(serverSslHandler);
                ch.pipeline().addLast(new SslEventHandler(serverEvent));
            }
        }).bind(new InetSocketAddress(0)).syncUninterruptibly().channel();
        ChannelFuture future = new Bootstrap().group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) {
                ch.pipeline().addLast(clientSslHandler);
                ch.pipeline().addLast(new SslEventHandler(clientEvent));
            }
        }).connect(sc.localAddress());
        cc = future.syncUninterruptibly().channel();
        Throwable clientCause = clientSslHandler.handshakeFuture().await().cause();
        assertThat(clientCause, CoreMatchers.<Throwable>instanceOf(SSLException.class));
        assertThat(clientCause.getCause(), not(CoreMatchers.<Throwable>instanceOf(ClosedChannelException.class)));
        Throwable serverCause = serverSslHandler.handshakeFuture().await().cause();
        assertThat(serverCause, CoreMatchers.<Throwable>instanceOf(SSLException.class));
        assertThat(serverCause.getCause(), not(CoreMatchers.<Throwable>instanceOf(ClosedChannelException.class)));
        cc.close().syncUninterruptibly();
        sc.close().syncUninterruptibly();
        Throwable eventClientCause = clientEvent.get().cause();
        assertThat(eventClientCause, CoreMatchers.<Throwable>instanceOf(SSLException.class));
        assertThat(eventClientCause.getCause(), not(CoreMatchers.<Throwable>instanceOf(ClosedChannelException.class)));
        Throwable serverEventCause = serverEvent.get().cause();
        assertThat(serverEventCause, CoreMatchers.<Throwable>instanceOf(SSLException.class));
        assertThat(serverEventCause.getCause(), not(CoreMatchers.<Throwable>instanceOf(ClosedChannelException.class)));
    } finally {
        group.shutdownGracefully();
        ReferenceCountUtil.release(sslClientCtx);
    }
}