AbstractIoUringChannel Class — netty Architecture

Source Code

transport-classes-io_uring/src/main/java/io/netty/channel/uring/AbstractIoUringChannel.java lines 73–1285

abstract class AbstractIoUringChannel extends AbstractChannel implements UnixChannel {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(AbstractIoUringChannel.class);
    final LinuxSocket socket;
    protected volatile boolean active;

    // Different masks for outstanding I/O operations.
    private static final int POLL_IN_SCHEDULED = 1;
    private static final int POLL_OUT_SCHEDULED = 1 << 2;
    private static final int POLL_RDHUP_SCHEDULED = 1 << 3;
    private static final int WRITE_SCHEDULED = 1 << 4;
    private static final int READ_SCHEDULED = 1 << 5;
    private static final int CONNECT_SCHEDULED = 1 << 6;

    private short opsId = Short.MIN_VALUE;

    private long pollInId;
    private long pollOutId;
    private long pollRdhupId;
    private long connectId;

    // A byte is enough for now.
    private byte ioState;

    // It's possible that multiple read / writes are issued. We need to keep track of these.
    // Let's limit the amount of pending writes and reads by Short.MAX_VALUE. Maybe Byte.MAX_VALUE would also be good
    // enough but let's be a bit more flexible for now.
    private short numOutstandingWrites;
    // A value of -1 means that multi-shot is used and so reads will be issued as long as the request is not canceled.
    private short numOutstandingReads;

    private boolean readPending;
    private boolean inReadComplete;
    private boolean socketHasMoreData;

    private static final class DelayedClose {
        private final ChannelPromise promise;
        private final Throwable cause;
        private final ClosedChannelException closeCause;

        DelayedClose(ChannelPromise promise, Throwable cause, ClosedChannelException closeCause) {
            this.promise = promise;
            this.cause = cause;
            this.closeCause = closeCause;
        }
    }
    private DelayedClose delayedClose;
    private boolean inputClosedSeenErrorOnRead;

    /**
     * The future of the current connection attempt.  If not null, subsequent connection attempts will fail.
     */
    private ChannelPromise connectPromise;
    private ScheduledFuture<?> connectTimeoutFuture;
    private SocketAddress requestedRemoteAddress;
    private CleanableDirectBuffer cleanable;
    private ByteBuffer remoteAddressMemory;
    private MsgHdrMemoryArray msgHdrMemoryArray;

    private IoRegistration registration;

    private volatile SocketAddress local;
    private volatile SocketAddress remote;

    AbstractIoUringChannel(final Channel parent, LinuxSocket socket, boolean active) {
        super(parent);
        this.socket = checkNotNull(socket, "fd");

        if (active) {
            // Directly cache the remote and local addresses
            // See https://github.com/netty/netty/issues/2359
            this.active = true;
            this.local = socket.localAddress();
            this.remote = socket.remoteAddress();
        }

        logger.trace("Create {} Socket: {}", this instanceof ServerChannel ? "Server" : "Channel", socket.intValue());
    }

    AbstractIoUringChannel(Channel parent, LinuxSocket fd, SocketAddress remote) {
        super(parent);
        this.socket = checkNotNull(fd, "fd");