testConnectWith0RTT() — netty Function Reference

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicChannelConnectTest.java lines 851–983

    @ParameterizedTest
    @MethodSource("newSslTaskExecutors")
    public void testConnectWith0RTT(Executor executor) throws Throwable {
        final CountDownLatch readLatch = new CountDownLatch(1);
        Channel server = QuicTestUtils.newServer(QuicTestUtils.newQuicServerBuilder(executor,
                        QuicSslContextBuilder.forServer(
                                        QuicTestUtils.SELF_SIGNED_CERTIFICATE.privateKey(), null,
                                        QuicTestUtils.SELF_SIGNED_CERTIFICATE.certificate())
                                .applicationProtocols(QuicTestUtils.PROTOS)
                                .earlyData(true)
                                .build()),
                TestQuicTokenHandler.INSTANCE, new ChannelInboundHandlerAdapter() {
                    @Override
                    public boolean isSharable() {
                        return true;
                    }
                }, new ChannelInboundHandlerAdapter() {
                    @Override
                    public boolean isSharable() {
                        return true;
                    }

                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) {
                        ByteBuf buffer = (ByteBuf) msg;
                        try {
                            assertEquals(4, buffer.readableBytes());
                            assertEquals(1, buffer.readInt());
                            readLatch.countDown();
                            ctx.close();
                            ctx.channel().parent().close();
                        } finally {
                            buffer.release();
                        }
                    }
                });
        InetSocketAddress address = (InetSocketAddress) server.localAddress();

        QuicSslContext sslContext = QuicSslContextBuilder.forClient()
                .trustManager(InsecureTrustManagerFactory.INSTANCE)
                .applicationProtocols(QuicTestUtils.PROTOS)
                .earlyData(true)
                .build();
        Channel channel = QuicTestUtils.newClient(QuicTestUtils.newQuicClientBuilder(executor, sslContext)
                .sslEngineProvider(q -> sslContext.newEngine(q.alloc(), "localhost", 9999)));
        final CountDownLatch activeLatch = new CountDownLatch(1);
        final CountDownLatch eventLatch = new CountDownLatch(1);
        final CountDownLatch streamLatch = new CountDownLatch(1);
        final AtomicReference<Throwable> errorRef = new AtomicReference<>();

        try {
            QuicChannel quicChannel = QuicTestUtils.newQuicChannelBootstrap(channel)
                    .handler(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
                            if (evt instanceof SslEarlyDataReadyEvent) {
                                errorRef.set(new AssertionFailedError("Shouldn't be called on the first connection"));
                            }
                            ctx.fireUserEventTriggered(evt);
                        }
                    })
                    .streamHandler(new ChannelInboundHandlerAdapter())
                    .remoteAddress(address)
                    .connect()
                    .get();

            QuicClientSessionCache cache = ((QuicheQuicSslContext) sslContext).getSessionCache();

            // Let's spin until the session shows up in the cache. This is needed as this might happen a bit after
            // the connection is already established.
            // See https://commondatastorage.googleapis.com/chromium-boringssl-docs/ssl.h.html#SSL_CTX_sess_set_new_cb
            while (!cache.hasSession("localhost", 9999)) {
                // Check again in 100ms.
                Thread.sleep(100);
            }

            quicChannel.close().sync();

            if (errorRef.get() != null) {
                throw errorRef.get();
            }