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

Example 91 with EventLoopGroup

use of org.apache.flink.shaded.netty4.io.netty.channel.EventLoopGroup 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);
    }
}

Example 92 with EventLoopGroup

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

the class SslHandlerTest method testHandshakeTimeoutBecauseExecutorNotExecute.

private static void testHandshakeTimeoutBecauseExecutorNotExecute(final boolean client) throws Exception {
    final SslContext sslClientCtx = SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).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;
    Channel cc = null;
    final SslHandler clientSslHandler = sslClientCtx.newHandler(UnpooledByteBufAllocator.DEFAULT, new Executor() {

        @Override
        public void execute(Runnable command) {
            if (!client) {
                command.run();
            }
        // Do nothing to simulate slow execution.
        }
    });
    if (client) {
        clientSslHandler.setHandshakeTimeout(100, TimeUnit.MILLISECONDS);
    }
    final SslHandler serverSslHandler = sslServerCtx.newHandler(UnpooledByteBufAllocator.DEFAULT, new Executor() {

        @Override
        public void execute(Runnable command) {
            if (client) {
                command.run();
            }
        // Do nothing to simulate slow execution.
        }
    });
    if (!client) {
        serverSslHandler.setHandshakeTimeout(100, TimeUnit.MILLISECONDS);
    }
    try {
        sc = new ServerBootstrap().group(group).channel(NioServerSocketChannel.class).childHandler(serverSslHandler).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);
            }
        }).connect(sc.localAddress());
        cc = future.syncUninterruptibly().channel();
        if (client) {
            Throwable cause = clientSslHandler.handshakeFuture().await().cause();
            assertThat(cause, CoreMatchers.<Throwable>instanceOf(SslHandshakeTimeoutException.class));
            assertFalse(serverSslHandler.handshakeFuture().await().isSuccess());
        } else {
            Throwable cause = serverSslHandler.handshakeFuture().await().cause();
            assertThat(cause, CoreMatchers.<Throwable>instanceOf(SslHandshakeTimeoutException.class));
            assertFalse(clientSslHandler.handshakeFuture().await().isSuccess());
        }
    } finally {
        if (cc != null) {
            cc.close().syncUninterruptibly();
        }
        if (sc != null) {
            sc.close().syncUninterruptibly();
        }
        group.shutdownGracefully();
        ReferenceCountUtil.release(sslClientCtx);
    }
}

Example 93 with EventLoopGroup

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

the class SslHandlerTest method testHandshakeWithExecutor.

private static void testHandshakeWithExecutor(Executor executor, SslProvider provider, boolean mtls) throws Throwable {
    final SelfSignedCertificate cert = new SelfSignedCertificate();
    final SslContext sslClientCtx;
    final SslContext sslServerCtx;
    if (mtls) {
        sslClientCtx = SslContextBuilder.forClient().protocols(SslProtocols.TLS_v1_2).trustManager(InsecureTrustManagerFactory.INSTANCE).keyManager(cert.key(), cert.cert()).sslProvider(provider).build();
        sslServerCtx = SslContextBuilder.forServer(cert.key(), cert.cert()).protocols(SslProtocols.TLS_v1_2).trustManager(InsecureTrustManagerFactory.INSTANCE).clientAuth(ClientAuth.REQUIRE).sslProvider(provider).build();
    } else {
        sslClientCtx = SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).sslProvider(provider).build();
        sslServerCtx = SslContextBuilder.forServer(cert.key(), cert.cert()).sslProvider(provider).build();
    }
    EventLoopGroup group = new NioEventLoopGroup();
    Channel sc = null;
    Channel cc = null;
    final SslHandler clientSslHandler = new SslHandler(sslClientCtx.newEngine(UnpooledByteBufAllocator.DEFAULT), executor);
    final SslHandler serverSslHandler = new SslHandler(sslServerCtx.newEngine(UnpooledByteBufAllocator.DEFAULT), executor);
    final AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
    try {
        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(ChannelHandlerContext ctx, Throwable cause) {
                        causeRef.compareAndSet(null, cause);
                    }
                });
            }
        }).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 ChannelInboundHandlerAdapter() {

                    @Override
                    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
                        causeRef.compareAndSet(null, cause);
                    }
                });
            }
        }).connect(sc.localAddress());
        cc = future.syncUninterruptibly().channel();
        assertTrue(clientSslHandler.handshakeFuture().await().isSuccess());
        assertTrue(serverSslHandler.handshakeFuture().await().isSuccess());
        Throwable cause = causeRef.get();
        if (cause != null) {
            throw cause;
        }
    } finally {
        if (cc != null) {
            cc.close().syncUninterruptibly();
        }
        if (sc != null) {
            sc.close().syncUninterruptibly();
        }
        group.shutdownGracefully();
        ReferenceCountUtil.release(sslClientCtx);
    }
}

Example 94 with EventLoopGroup

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

the class SslHandlerTest method testCloseOnHandshakeFailure.

@Test
@Timeout(value = 10000, unit = TimeUnit.MILLISECONDS)
public void testCloseOnHandshakeFailure() throws Exception {
    final SelfSignedCertificate ssc = new SelfSignedCertificate();
    final SslContext sslServerCtx = SslContextBuilder.forServer(ssc.key(), ssc.cert()).build();
    final SslContext sslClientCtx = SslContextBuilder.forClient().trustManager(new SelfSignedCertificate().cert()).build();
    EventLoopGroup group = new NioEventLoopGroup(1);
    Channel sc = null;
    Channel cc = null;
    try {
        LocalAddress address = new LocalAddress(getClass().getSimpleName() + ".testCloseOnHandshakeFailure");
        ServerBootstrap sb = new ServerBootstrap().group(group).channel(LocalServerChannel.class).childHandler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) {
                ch.pipeline().addLast(sslServerCtx.newHandler(ch.alloc()));
            }
        });
        sc = sb.bind(address).syncUninterruptibly().channel();
        final AtomicReference<SslHandler> sslHandlerRef = new AtomicReference<SslHandler>();
        Bootstrap b = new Bootstrap().group(group).channel(LocalChannel.class).handler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) {
                SslHandler handler = sslClientCtx.newHandler(ch.alloc());
                // We propagate the SslHandler via an AtomicReference to the outer-scope as using
                // pipeline.get(...) may return null if the pipeline was teared down by the time we call it.
                // This will happen if the channel was closed in the meantime.
                sslHandlerRef.set(handler);
                ch.pipeline().addLast(handler);
            }
        });
        cc = b.connect(sc.localAddress()).syncUninterruptibly().channel();
        SslHandler handler = sslHandlerRef.get();
        handler.handshakeFuture().awaitUninterruptibly();
        assertFalse(handler.handshakeFuture().isSuccess());
        cc.closeFuture().syncUninterruptibly();
    } finally {
        if (cc != null) {
            cc.close().syncUninterruptibly();
        }
        if (sc != null) {
            sc.close().syncUninterruptibly();
        }
        group.shutdownGracefully();
        ReferenceCountUtil.release(sslServerCtx);
        ReferenceCountUtil.release(sslClientCtx);
    }
}

Example 95 with EventLoopGroup

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

the class SniHandlerTest method testSniWithApnHandler.

@ParameterizedTest(name = "{index}: sslProvider={0}")
@MethodSource("data")
public void testSniWithApnHandler(SslProvider provider) throws Exception {
    SslContext nettyContext = makeSslContext(provider, true);
    SslContext sniContext = makeSslContext(provider, true);
    final SslContext clientContext = makeSslClientContext(provider, true);
    try {
        final AtomicBoolean serverApnCtx = new AtomicBoolean(false);
        final AtomicBoolean clientApnCtx = new AtomicBoolean(false);
        final CountDownLatch serverApnDoneLatch = new CountDownLatch(1);
        final CountDownLatch clientApnDoneLatch = new CountDownLatch(1);
        final DomainNameMapping<SslContext> mapping = new DomainNameMappingBuilder<SslContext>(nettyContext).add("*.netty.io", nettyContext).add("sni.fake.site", sniContext).build();
        final SniHandler handler = new SniHandler(mapping);
        EventLoopGroup group = new NioEventLoopGroup(2);
        Channel serverChannel = null;
        Channel clientChannel = null;
        try {
            ServerBootstrap sb = new ServerBootstrap();
            sb.group(group);
            sb.channel(NioServerSocketChannel.class);
            sb.childHandler(new ChannelInitializer<Channel>() {

                @Override
                protected void initChannel(Channel ch) throws Exception {
                    ChannelPipeline p = ch.pipeline();
                    // Server side SNI.
                    p.addLast(handler);
                    // Catch the notification event that APN has completed successfully.
                    p.addLast(new ApplicationProtocolNegotiationHandler("foo") {

                        @Override
                        protected void configurePipeline(ChannelHandlerContext ctx, String protocol) {
                            // addresses issue #9131
                            serverApnCtx.set(ctx.pipeline().context(this) != null);
                            serverApnDoneLatch.countDown();
                        }
                    });
                }
            });
            Bootstrap cb = new Bootstrap();
            cb.group(group);
            cb.channel(NioSocketChannel.class);
            cb.handler(new ChannelInitializer<Channel>() {

                @Override
                protected void initChannel(Channel ch) throws Exception {
                    ch.pipeline().addLast(new SslHandler(clientContext.newEngine(ch.alloc(), "sni.fake.site", -1)));
                    // Catch the notification event that APN has completed successfully.
                    ch.pipeline().addLast(new ApplicationProtocolNegotiationHandler("foo") {

                        @Override
                        protected void configurePipeline(ChannelHandlerContext ctx, String protocol) {
                            // addresses issue #9131
                            clientApnCtx.set(ctx.pipeline().context(this) != null);
                            clientApnDoneLatch.countDown();
                        }
                    });
                }
            });
            serverChannel = sb.bind(new InetSocketAddress(0)).sync().channel();
            ChannelFuture ccf = cb.connect(serverChannel.localAddress());
            assertTrue(ccf.awaitUninterruptibly().isSuccess());
            clientChannel = ccf.channel();
            assertTrue(serverApnDoneLatch.await(5, TimeUnit.SECONDS));
            assertTrue(clientApnDoneLatch.await(5, TimeUnit.SECONDS));
            assertTrue(serverApnCtx.get());
            assertTrue(clientApnCtx.get());
            assertThat(handler.hostname(), is("sni.fake.site"));
            assertThat(handler.sslContext(), is(sniContext));
        } finally {
            if (serverChannel != null) {
                serverChannel.close().sync();
            }
            if (clientChannel != null) {
                clientChannel.close().sync();
            }
            group.shutdownGracefully(0, 0, TimeUnit.MICROSECONDS);
        }
    } finally {
        releaseAll(clientContext, nettyContext, sniContext);
    }
}