QuicTestUtils Class — netty Architecture

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicTestUtils.java lines 41–210

final class QuicTestUtils {
    static final String[] PROTOS = new String[]{"hq-29"};
    static final SelfSignedCertificate SELF_SIGNED_CERTIFICATE;

    private static final int DATAGRAM_SIZE = 2048;

    static {
        SelfSignedCertificate cert;
        try {
            cert = new SelfSignedCertificate();
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
        SELF_SIGNED_CERTIFICATE = cert;
    }

    private QuicTestUtils() {
    }

    private static final EventLoopGroup GROUP = Epoll.isAvailable() ?
            new MultiThreadIoEventLoopGroup(EpollIoHandler.newFactory()) :
            new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());

    static final ChannelHandlerAdapter NOOP_HANDLER = new ChannelHandlerAdapter() {
        @Override
        public boolean isSharable() {
            return true;
        }
    };

    static {
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                try {
                    GROUP.shutdownGracefully().sync();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
    }

    static Channel newClient(Executor sslTaskExecutor) throws Exception {
        return newClient(newQuicClientBuilder(sslTaskExecutor));
    }

    private static Bootstrap newBootstrap() {
        Bootstrap bs = new Bootstrap();
        if (Epoll.isAvailable()) {
            bs.channel(EpollDatagramChannel.class)
                    // Use recvmmsg when possible.
                    .option(EpollChannelOption.MAX_DATAGRAM_PAYLOAD_SIZE, DATAGRAM_SIZE)
                    .option(ChannelOption.RCVBUF_ALLOCATOR, new FixedRecvByteBufAllocator(DATAGRAM_SIZE * 8));
        } else {
            bs.channel(NioDatagramChannel.class)
                    .option(ChannelOption.RCVBUF_ALLOCATOR, new FixedRecvByteBufAllocator(DATAGRAM_SIZE));
        }
        return bs.group(GROUP);
    }

    static Channel newClient(QuicClientCodecBuilder builder) throws Exception {
        return newBootstrap()
                // We don't want any special handling of the channel so just use a dummy handler.
                .handler(builder.build())
                .bind(new InetSocketAddress(NetUtil.LOCALHOST4, 0)).sync().channel();
    }

    static QuicChannelBootstrap newQuicChannelBootstrap(Channel channel) {
        QuicChannelBootstrap bs = QuicChannel.newBootstrap(channel);
        if (Epoll.isAvailable()) {
            bs.option(QuicChannelOption.SEGMENTED_DATAGRAM_PACKET_ALLOCATOR,
                    EpollQuicUtils.newSegmentedAllocator(10));
        }
        return bs;
    }

    static QuicClientCodecBuilder newQuicClientBuilder(Executor sslTaskExecutor) {
        return newQuicClientBuilder(sslTaskExecutor, QuicSslContextBuilder.forClient()
                .trustManager(InsecureTrustManagerFactory.INSTANCE).applicationProtocols(PROTOS).build());
    }