fix(h2): keep queued requests alive when the last stream closes

lib/dispatcher/client-h2.js

@@ -779,10 +779,12 @@ function noop () {}
 
 function closeStreamSession (stream) {
   const session = stream[kHTTP2Session]
+  const client = session[kClient]
 
   stream[kHTTP2Session] = null
   session[kOpenStreams] -= 1
-  if (session[kOpenStreams] === 0) {
+  // A session that received GOAWAY does not need to stay ref'd for queued requests.
+  if (session[kOpenStreams] === 0 && (client[kSize] === 0 || session[kReceivedGoAway])) {
     unrefH2Session(session)
     setHttp2IdleTimeout(session)
   }

test/fixtures/h2-last-stream-client.js

@@ -0,0 +1,49 @@
+'use strict'
+
+// Child of the last-stream-close test in http2-max-concurrent-streams-zero-unref.js.
+// Do not add anything else here that keeps the event loop alive.
+const { once } = require('node:events')
+const { Client } = require('../..')
+
+const client = new Client(`https://localhost:${process.argv[2]}`, {
+  allowH2: true,
+  connect: { rejectUnauthorized: false },
+  headersTimeout: 500
+})
+
+let outstanding = false
+
+process.on('beforeExit', () => {
+  if (outstanding) {
+    outstanding = false
+    process.send('exited with the request outstanding')
+  }
+})
+
+async function main () {
+  const warm = await client.request({ path: '/', method: 'GET' })
+  const bodyDone = warm.body.dump()
+  process.send('warmed')
+
+  await once(process, 'message')
+
+  outstanding = true
+  const queued = client.request({ path: '/queued', method: 'GET' })
+  process.send('queued')
+
+  await bodyDone
+
+  const outcome = await queued.then(
+    async ({ body }) => { await body.dump(); return 'settled' },
+    (err) => err.code ?? err.message
+  )
+  outstanding = false
+  process.send(outcome)
+
+  await client.close()
+}
+
+main().catch((err) => {
+  process.exitCode = 1
+  process.send(`failed: ${err.code ?? err.message}`)
+})

test/http2-max-concurrent-streams-zero-unref.js

@@ -46,3 +46,43 @@ test('a queued request keeps the process alive while the peer allows no new stre
   t.assert.strictEqual(code, 0)
   t.assert.deepStrictEqual(messages, ['warmed', 'queued', 'UND_ERR_HEADERS_TIMEOUT'])
 })
+
+test('a queued request keeps the process alive when the last stream closes', { timeout: 10000 }, async (t) => {
+  const server = createSecureServer({ key, cert })
+  t.after(() => server.close())
+
+  let activeStream
+  server.on('stream', (stream) => {
+    stream.on('error', () => {})
+    stream.respond({ ':status': 200 })
+    activeStream = stream
+  })
+
+  let session
+  server.on('session', (s) => { session = s })
+
+  server.listen(0)
+  await once(server, 'listening')
+
+  const child = fork(join(__dirname, 'fixtures/h2-last-stream-client.js'), [String(server.address().port)])
+  t.after(() => child.kill())
+
+  const messages = []
+  child.on('message', (message) => {
+    messages.push(message)
+
+    if (message === 'warmed') {
+      try {
+        session.settings({ maxConcurrentStreams: 0 }, () => child.send('drained', () => {}))
+      } catch {}
+    } else if (message === 'queued') {
+      activeStream.end('ok')
+    }
+  })
+
+  const [code, signal] = await once(child, 'close')
+
+  t.assert.strictEqual(signal, null)
+  t.assert.strictEqual(code, 0)
+  t.assert.deepStrictEqual(messages, ['warmed', 'queued', 'UND_ERR_HEADERS_TIMEOUT'])
+})