TimeoutHandler Class — netty Architecture

Source Code

codec-classes-quic/src/main/java/io/netty/handler/codec/quic/QuicheQuicChannel.java lines 1991–2064

    private final class TimeoutHandler implements Runnable {
        private ScheduledFuture<?> timeoutFuture;

        @Override
        public void run() {
            QuicheQuicConnection conn = connection;
            if (conn.isFreed()) {
                return;
            }
            if (!freeIfClosed()) {
                long connAddr = conn.address();
                timeoutFuture = null;
                // Notify quiche there was a timeout.
                Quiche.quiche_conn_on_timeout(connAddr);
                if (!freeIfClosed()) {
                    // We need to call connectionSend when a timeout was triggered.
                    // See https://docs.rs/quiche/0.6.0/quiche/struct.Connection.html#method.send.
                    if (connectionSend(conn) != SendResult.NONE) {
                        flushParent();
                    }
                    boolean closed = freeIfClosed();
                    if (!closed) {
                        // The connection is alive, reschedule.
                        scheduleTimeout();
                    }
                }
            }
        }

        // Schedule timeout.
        // See https://docs.rs/quiche/0.6.0/quiche/#generating-outgoing-packets
        void scheduleTimeout() {
            QuicheQuicConnection conn = connection;
            if (conn.isFreed()) {
                cancel();
                return;
            }
            if (conn.isClosed()) {
                cancel();
                unsafe().close(newPromise());
                return;
            }
            long nanos = Quiche.quiche_conn_timeout_as_nanos(conn.address());
            if (nanos < 0 || nanos == Long.MAX_VALUE) {
                // No timeout needed.
                cancel();
                return;
            }
            if (timeoutFuture == null) {
                timeoutFuture = eventLoop().schedule(this,
                        nanos, TimeUnit.NANOSECONDS);
            } else {
                long remaining = timeoutFuture.getDelay(TimeUnit.NANOSECONDS);
                if (remaining <= 0) {
                    // This means the timer already elapsed. In this case just cancel the future and call run()
                    // directly. This will ensure we correctly call quiche_conn_on_timeout() etc.
                    cancel();
                    run();
                } else if (remaining > nanos) {
                    // The new timeout is smaller then what was scheduled before. Let's cancel the old timeout
                    // and schedule a new one.
                    cancel();
                    timeoutFuture = eventLoop().schedule(this, nanos, TimeUnit.NANOSECONDS);
                }
            }
        }

        void cancel() {
            if (timeoutFuture != null) {
                timeoutFuture.cancel(false);
                timeoutFuture = null;
            }
        }
    }