quic: write desired size needs update on maxstream

src/quic/application.cc

@@ -425,6 +425,7 @@ class DefaultApplication final : public Session::Application {
     // The peer granted more flow control for this stream. Re-schedule
     // it so SendPendingData will resume writing.
     DCHECK_NOT_NULL(stream);
+    stream->UpdateWriteDesiredSize();  // the stream might be blocked on js side
     stream->Schedule(&stream_queue_);
   }
 

src/quic/http3.cc

@@ -375,6 +375,7 @@ class Http3ApplicationImpl final : public Session::Application {
     Debug(&session(),
           "HTTP/3 application extending max stream data to %" PRIu64,
           max_data);
+    stream->UpdateWriteDesiredSize();  // the stream might be blocked on js side
     nghttp3_conn_unblock_stream(*this, stream->id());
   }
 

test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs

@@ -0,0 +1,80 @@
+// Flags: --experimental-quic --experimental-stream-iter --no-warnings
+
+// Test: Quic maxstreamdata updates on http/3
+// Client sends a body that precisely fills the window size,
+// and verifies that it is data transfer is not stalled.
+
+import { hasQuic, skip } from '../common/index.mjs';
+import { readFile } from 'node:fs/promises';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+const { listen, connect } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+const { drainableProtocol } = await import('stream/iter');
+
+const keys = 'test/fixtures/keys';
+const key = createPrivateKey(await readFile(`${keys}/agent1-key.pem`));
+const cert = await readFile(`${keys}/agent1-cert.pem`);
+
+const WINDOW = 4096;
+// Fills the window exactly: HTTP/3 spends 11 of those bytes on framing (8 for
+// the HEADERS frame below, 3 for the DATA frame header). The send buffer then
+// empties at the same moment the window reaches zero, leaving nothing in
+// flight to ack. Any other size leaves bytes queued, and the ack for those
+// wakes the writer instead, hiding the bug.
+const BODY = WINDOW - 11;
+
+let letServerRead;
+const serverMayRead = new Promise((resolve) => { letServerRead = resolve; });
+
+const endpoint = await listen((session) => {
+  session.onstream = async (stream) => {
+    await serverMayRead;
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of stream) { /* reading extends the window */ }
+  };
+}, {
+  sni: { '*': { keys: [key], certs: [cert] } },
+  transportParams: {
+    initialMaxStreamDataBidiRemote: WINDOW,
+    initialMaxData: 1024 * 1024,
+  },
+  onheaders() { this.sendHeaders({ ':status': '200' }); },
+});
+
+const session = await connect(endpoint.address, {
+  servername: 'localhost',
+  verifyPeer: 'manual',
+});
+await session.opened;
+
+// Budget well above the window, so the window is what stops the writer.
+const stream = await session.createBidirectionalStream({ budget: 1024 * 1024 });
+stream.sendHeaders({
+  ':method': 'POST',
+  ':path': '/',
+  ':scheme': 'https',
+  ':authority': 'localhost',
+}, { terminal: false });
+
+const writer = stream.writer;
+writer.writeSync(new Uint8Array(BODY));
+
+// Long enough for every byte to be acked. The peer acks as data arrives,
+// whether or not its application has read any of it, so by now the window is
+// exhausted, the send buffer is empty, and no further ACK can arrive.
+await sleep(500);
+
+const watchdog = setTimeout(() => {
+  console.error('STALLED: no drain after MAX_STREAM_DATA');
+  process.exit(1);
+}, 5000);
+
+letServerRead();                 // Extend the window, with no ack attached
+await writer[drainableProtocol]();
+
+clearTimeout(watchdog);
+process.exit(0);

test/parallel/test-quic-maxstreamdata-external-buffer-failure.mjs

@@ -0,0 +1,75 @@
+// Flags: --experimental-quic --experimental-stream-iter --no-warnings
+
+// Test: Quic maxstreamdata updates on pure quic
+// Client sends a body that precisely fills the window size,
+// and verifies that it is data transfer is not stalled.
+
+import { hasQuic, skip } from '../common/index.mjs';
+import { readFile } from 'node:fs/promises';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+const { listen, connect } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+const { drainableProtocol } = await import('stream/iter');
+
+const keys = 'test/fixtures/keys';
+const key = createPrivateKey(await readFile(`${keys}/agent1-key.pem`));
+const cert = await readFile(`${keys}/agent1-cert.pem`);
+
+const WINDOW = 4096;
+// Fills the window exactly: HTTP/3 spends 11 of those bytes on framing (8 for
+// the HEADERS frame below, 3 for the DATA frame header). The send buffer then
+// empties at the same moment the window reaches zero, leaving nothing in
+// flight to ack. Any other size leaves bytes queued, and the ack for those
+// wakes the writer instead, hiding the bug.
+const BODY = WINDOW;
+
+let letServerRead;
+const serverMayRead = new Promise((resolve) => { letServerRead = resolve; });
+
+const endpoint = await listen((session) => {
+  session.onstream = async (stream) => {
+    await serverMayRead;
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of stream) { /* reading extends the window */ }
+  };
+}, {
+  alpn: 'foo',
+  sni: { '*': { keys: [key], certs: [cert] } },
+  transportParams: {
+    initialMaxStreamDataBidiRemote: WINDOW,
+    initialMaxData: 1024 * 1024,
+  }
+});
+
+const session = await connect(endpoint.address, {
+  servername: 'localhost',
+  verifyPeer: 'manual',
+  alpn: 'foo'
+});
+await session.opened;
+
+// Budget well above the window, so the window is what stops the writer.
+const stream = await session.createBidirectionalStream({ budget: 1024 * 1024 });
+
+const writer = stream.writer;
+writer.writeSync(new Uint8Array(BODY));
+
+// Long enough for every byte to be acked. The peer acks as data arrives,
+// whether or not its application has read any of it, so by now the window is
+// exhausted, the send buffer is empty, and no further ACK can arrive.
+await sleep(500);
+
+const watchdog = setTimeout(() => {
+  console.error('STALLED: no drain after MAX_STREAM_DATA');
+  process.exit(1);
+}, 5000);
+
+letServerRead();                 // Extend the window, with no ack attached
+await writer[drainableProtocol]();
+
+clearTimeout(watchdog);
+process.exit(0);