quic: stats assertion on close

[splitice]

• Version: 15.0.1
• Platform: x64
• Subsystem: quic

What steps will reproduce the bug?

server.js

'use strict';

const fs = require('fs')

const key = fs.readFileSync('./key.pem');
const cert = fs.readFileSync('./cert.pem');

const { createQuicSocket } = require('net');

const toSend = Buffer.alloc(1024 * 64)

// Create the QUIC UDP IPv4 socket bound to local IP port 1234
const socket = createQuicSocket({ endpoint: { port: 1234 } });

socket.on('session', async (session) => {
    // A new server side session has been created!

    setInterval(async () => {

        console.log("new stream")
        const stream = await session.openStream()
        await stream.write(toSend)
        await stream.write(toSend)
        await stream.write(toSend)

        console.log("ending stream")
        stream.close()
    }, 100)

});

(async function () {
    await socket.listen({ key, cert, alpn: 'hello' });
    console.log('The socket is listening for sessions!');
})();

client.js

const { createQuicSocket } = require('net');
const net = require('net')
const debug = console.log

// Create a QuicSocket associated with localhost and port 1234
const socket = createQuicSocket({ endpoint: { port: 0 } });

const backendConnection = new net.Socket({ allowHalfOpen: true });
backendConnection.connect(80, '127.0.0.1', () => {
    (async function () {
        const client = await socket.connect({
            address: '127.0.0.1',
            port: 1234,
            alpn: 'hello'
        });

        client.on('secure', async () => {
            console.log('secure')
            client.on('stream', async (quicStream) => {
                console.log('stream')

                quicStream.on('end', function () {
                    console.log('early end')
                })

                quicStream.pipe(backendConnection, { end: false })


                quicStream.on('finish', () => {
                    debug("Completed sending response to tunnel client")

                    quicStream.unpipe(backendConnection)
                    quicStream.removeAllListeners()
                    quicStream.close()
                });

                // Handle quick stream errors
                quicStream.on('error', (err) => {
                    debug(`Quic Stream Error ${err}`)
                    quicStream.removeAllListeners()
                    quicStream.end()
                })

            })
        })
        // The QuicClientSession can now be used for application data
    })();
})

How often does it reproduce? Is there a required condition?

Usually within the first few iterations.

What is the expected behavior?

Script creates a stream, transfers data, closes.

What do you see instead?

node[5639]: ../src/quic/node_quic_stream-inl.h:29:void node::quic::QuicStream::set_final_size(uint64_t): Assertion `(final_size) <= (GetStat(&QuicStreamStats::final_size))' failed

Additional information

This is similar to an issue I reported against nodejs/quic that remain open.

[splitice]

Original issue nodejs/quic#383 responded to by @jasnell

Unlike last time where I did the testing on arm as well as x64 this time the entirety of the testing was on a loopback device of a x64 virtual machine running in docker.

[jasnell]

Closing as no longer relevant since the quic bits were removed.