QuicCodecDispatcher Class — netty Architecture

Source Code

codec-classes-quic/src/main/java/io/netty/handler/codec/quic/QuicCodecDispatcher.java lines 51–325

public abstract class QuicCodecDispatcher extends ChannelInboundHandlerAdapter {
    // 20 is the max as per RFC.
    // See https://datatracker.ietf.org/doc/html/rfc9000#section-17.2
    private static final int MAX_LOCAL_CONNECTION_ID_LENGTH = 20;

    // Use a CopyOnWriteArrayList as modifications to the List should only happen during bootstrapping and teardown
    // of the channels.
    private final List<ChannelHandlerContextDispatcher> contextList = new CopyOnWriteArrayList<>();
    private final int localConnectionIdLength;

    /**
     * Create a new instance using the default connection id length.
     */
    protected QuicCodecDispatcher() {
        this(MAX_LOCAL_CONNECTION_ID_LENGTH);
    }

    /**
     * Create a new instance
     *
     * @param localConnectionIdLength   the local connection id length. This must be between 10 and 20.
     */
    protected QuicCodecDispatcher(int localConnectionIdLength) {
        // Let's use 10 as a minimum to ensure we still have some bytes left for randomness as we already use
        // 2 of the bytes to encode the index.
        this.localConnectionIdLength = ObjectUtil.checkInRange(localConnectionIdLength,
                10, MAX_LOCAL_CONNECTION_ID_LENGTH, "localConnectionIdLength");
    }

    @Override
    public final boolean isSharable() {
        return true;
    }

    @Override
    public final void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        super.handlerAdded(ctx);

        ChannelHandlerContextDispatcher ctxDispatcher = new ChannelHandlerContextDispatcher(ctx);
        contextList.add(ctxDispatcher);
        int idx = contextList.indexOf(ctxDispatcher);
        try {
            QuicConnectionIdGenerator idGenerator = newIdGenerator((short) idx);
            initChannel(ctx.channel(), localConnectionIdLength, idGenerator);
        } catch (Exception e) {
            // Null out on exception and rethrow. We not remove the element as the indices need to be
            // stable.
            contextList.set(idx, null);
            throw e;
        }
    }

    @Override
    public final void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        super.handlerRemoved(ctx);

        for (int idx = 0; idx < contextList.size(); idx++) {
            ChannelHandlerContextDispatcher ctxDispatcher = contextList.get(idx);
            if (ctxDispatcher != null && ctxDispatcher.ctx.equals(ctx)) {
                // null out, so we can collect the ChannelHandlerContext that was stored in the List.
                contextList.set(idx, null);
                break;
            }
        }
    }

    @Override
    public final void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        DatagramPacket packet = (DatagramPacket) msg;
        ByteBuf connectionId = getDestinationConnectionId(packet.content(), localConnectionIdLength);
        if (connectionId != null) {
            int idx = decodeIndex(connectionId);
            if (contextList.size() > idx) {
                ChannelHandlerContextDispatcher selectedCtx = contextList.get(idx);
                if (selectedCtx != null) {
                    selectedCtx.fireChannelRead(msg);
                    return;
                }
            }
        }
        // We were not be-able to dispatch to a specific ChannelHandlerContext, just forward and let the