From 8268a05583415d31ef303c97157bac85d201c19c Mon Sep 17 00:00:00 2001 From: Diogo Martins Date: Sat, 14 Nov 2026 15:53:57 +0000 Subject: [PATCH] http2: an answer waiting on the client's credit has its unread upload credited, so a client that uploads everything first gets it (#588) RFC 9113 8.1 lets a server answer before its request has arrived. A client that reads its response only once its upload has ended, as .NET's HttpClient does with a content that is not duplex, credits the response only then. An answer past that client's stream window waited on the credit for its END_STREAM, while the server credited the request's stream only as its handler read: a handler that answered unread left the upload holding the server's stream window (InitialWindowSize, 256 KiB by default), and neither side could move. A streamed answer hung whether its handler awaited CompleteAsync, which waited for that credit, or left the completion to the stack, which waited the same way; a buffered one hung once the upload had filled its window before the handler returned, since the queued body was dropped uncredited. And a buffered answer parked on credit to a client that does credit while it uploads ended with no RST_STREAM(NO_ERROR) after its END_STREAM, the upload then credited nothing, so that request never completed. - Http2ResponseWriter.CompleteAsync no longer waits for the peer's credit: what the windows cannot take yet goes out in the background as credit arrives, END_STREAM last, and the stream is retired behind it. A buffered rest parked on credit takes the same path. - A stream whose handler is done while its answer waits on credit stays open behind it: what the handler left unread is credited and dropped, as the nghttp2 twin's reader does, and DATA still arriving is credited as it lands, still held to its stream window and content-length. - Once that answer's END_STREAM is out, a request still arriving is reset with NO_ERROR after it, as an answer that ends at once already is. - HandleData's crediting of DATA for a stream that had left the table under a parked buffered rest is gone: such a stream now stays in the table. IsCompleted is true once CompleteAsync has returned, its end possibly still waiting on credit, and a FlushAsync after CompleteAsync reports IsCompleted. A handler that waits on FlushAsync for that credit, its body unread, still waits until such a client gives up; Http2BodyReader's docs say so. Tests: Unit Http2EarlyAnswerParkedTests on the wire, and E2E EarlyAnswerTests with .NET's HttpClient over h2c, non-duplex and duplex, each failing at origin/main or with its part of the fix reverted. --- src/protocols/ioxide.http2/Http2BodyReader.cs | 33 ++- .../ioxide.http2/Http2Connection.Frames.cs | 20 +- .../ioxide.http2/Http2Connection.Streamed.cs | 15 +- .../ioxide.http2/Http2Connection.Write.cs | 39 +-- src/protocols/ioxide.http2/Http2Connection.cs | 79 +++++- .../ioxide.http2/Http2ResponseWriter.cs | 63 ++++- .../Protocols/EarlyAnswerTests.cs | 160 +++++++++++- .../Http2EarlyAnswerParkedTests.cs | 228 ++++++++++++++++++ .../Http2FlowControlTests.cs | 4 +- tests/Ioxide.Tests.Unit/Program.cs | 1 + 10 files changed, 564 insertions(+), 78 deletions(-) create mode 100644 tests/Ioxide.Tests.Unit/Http2EarlyAnswerParkedTests.cs diff --git a/src/protocols/ioxide.http2/Http2BodyReader.cs b/src/protocols/ioxide.http2/Http2BodyReader.cs index bc84bd78..a8f77dad 100644 --- a/src/protocols/ioxide.http2/Http2BodyReader.cs +++ b/src/protocols/ioxide.http2/Http2BodyReader.cs @@ -23,6 +23,14 @@ namespace ioxide.http2; /// /// The window is the stream's own. The connection's is opened to its maximum and kept there, so a /// handler that never reads holds back only its own upload, never the other streams'. +/// +/// A handler that answers without reading its body to the end leaves the rest to the connection +/// once it returns: while its response still waits on the client's credit, what arrives is credited +/// and dropped, and once the response has ended a request still arriving is reset with NO_ERROR. A +/// client that reads its response only once its upload has ended, as .NET's HttpClient does +/// with a content that is not duplex, can then finish both. A handler that instead waits on +/// for that credit, its body unread, waits until such a +/// client gives up. /// /// /// Single consumer, on any thread: a read made off the reactor is served on it. Each @@ -88,12 +96,18 @@ public ValueTask> ReadAsync() // Body bytes straight off a DATA frame. The span points into the connection's accumulator and // dies when the parser moves on, so it has to be copied. Never completes a parked reader - // inline: the wake is deferred to FireIfReady, after the parser unwinds. - internal void Push(ReadOnlySpan data) + // inline: the wake is deferred to FireIfReady, after the parser unwinds. False once the body has + // ended: its handler is done with it, and the caller credits bytes nobody will read. + internal bool Push(ReadOnlySpan data) { + if (_ended) + { + return false; + } + if (data.IsEmpty) { - return; + return true; } byte[] buffer = ArrayPool.Shared.Rent(data.Length); @@ -104,6 +118,7 @@ internal void Push(ReadOnlySpan data) { _owner.NoteBodyWake(this); } + return true; } /// End of body: END_STREAM, or a cut one once has said so. Idempotent. @@ -175,11 +190,12 @@ internal void Abort(string? reason = null) } // The handler is done with the request, or never got it: recycle everything, the chunk it held - // included, and complete a read it left parked. + // included, and complete a read it left parked. Ended, so DATA still on its way is credited as it + // arrives while the stream stays open for a response waiting on credit. internal void Drop() { ReleaseHandedOut(); - DropQueued(); + _owner.CreditBody(_streamId, DropQueued()); // Drained first, so the wake below reports end-of-body rather than handing out a chunk // whose stream is already gone. @@ -187,13 +203,16 @@ internal void Drop() FireIfReady(); } - // Owed no credit: the connection was charged for these on arrival, and their stream is done. - private void DropQueued() + // The connection was charged for these on arrival; only a stream still open is owed them, which CreditBody checks. + private int DropQueued() { + int dropped = 0; while (_chunks.TryDequeue(out (byte[] Buffer, int Length) chunk)) { + dropped += chunk.Length; ArrayPool.Shared.Return(chunk.Buffer); } + return dropped; } private void ReleaseHandedOut() diff --git a/src/protocols/ioxide.http2/Http2Connection.Frames.cs b/src/protocols/ioxide.http2/Http2Connection.Frames.cs index a49d89e9..878ea6c7 100644 --- a/src/protocols/ioxide.http2/Http2Connection.Frames.cs +++ b/src/protocols/ioxide.http2/Http2Connection.Frames.cs @@ -404,13 +404,7 @@ private void HandleData(in FrameHeader header, ReadOnlySpan payload) if (!_streams.TryGetValue(header.StreamId, out PendingRequest? pending)) { - // A buffered answer parked on credit still has its upload credited, so a client that credits the - // answer only once its upload ends can finish both. Any other stream's window went with it. - if (payload.Length > 0 && !ended && _responseWindows.ContainsKey(header.StreamId)) - { - WriteWindowUpdate(header.StreamId, payload.Length); - } - return; + return; // closed, so owed no credit (RFC 9113 5.1): a request whose answer waits on credit stays in _streams } // Past its window is a stream error (6.9), and its response stops with it; an empty frame may still end it (6.9.1). @@ -433,9 +427,14 @@ private void HandleData(in FrameHeader header, ReadOnlySpan payload) return; } + // Consumed now: a buffered body, one its handler is done with, or a streamed one's padding, its body credited as read. + int credit = payload.Length; if (pending.BodyReader is { } reader) { - reader.Push(body); + if (reader.Push(body)) + { + credit -= body.Length; + } } else { @@ -447,9 +446,8 @@ private void HandleData(in FrameHeader header, ReadOnlySpan payload) pending.AppendBody(body); } - // Consumed now: a buffered body, or a streamed one's padding, its body credited as read; an ended request is owed none. - int credit = pending.BodyReader is null ? payload.Length : payload.Length - body.Length; - if (credit > 0 && !ended) + // An ended request is owed none. + if (credit > 0 && !ended && !pending.RequestEnded) { CreditStream(pending, credit); } diff --git a/src/protocols/ioxide.http2/Http2Connection.Streamed.cs b/src/protocols/ioxide.http2/Http2Connection.Streamed.cs index 4167da9d..d1b6dd27 100644 --- a/src/protocols/ioxide.http2/Http2Connection.Streamed.cs +++ b/src/protocols/ioxide.http2/Http2Connection.Streamed.cs @@ -98,10 +98,17 @@ private async Task ServeStreamedAsync(Func body = response.Body; // a null response throws here, with the window still there for the 500 // Gone once the peer has reset the stream, and nothing may follow a reset (RFC 9113 5.1). if (!_responseWindows.Remove(streamId, out int window)) { - return; + return null; } WriteHeaders(streamId, response, endStream: body.Length == 0); - if (body.Length > 0) - { - WriteData(streamId, body.Span, window); - } + return body.Length > 0 ? WriteData(streamId, body.Span, window) : null; } private void WriteHeaders(int streamId, Http2Response response, bool endStream) @@ -426,7 +424,7 @@ private void WriteHeaders(int streamId, Http2Response response, bool endStream) } } - private void WriteData(int streamId, ReadOnlySpan body, int window) + private Http2ResponseWriter? WriteData(int streamId, ReadOnlySpan body, int window) { int offset = 0; @@ -441,8 +439,7 @@ private void WriteData(int streamId, ReadOnlySpan body, int window) { // Out of credit: the rest waits for a WINDOW_UPDATE the way a streamed response does. _responseWindows[streamId] = window; - ParkRest(streamId, body[offset..]); - return; + return ParkRest(streamId, body[offset..]); } bool last = offset + chunk >= body.Length; @@ -457,35 +454,17 @@ private void WriteData(int streamId, ReadOnlySpan body, int window) window -= chunk; offset += chunk; } + return null; } // Copied into a writer, because the body is the handler's again once it has returned. - private void ParkRest(int streamId, ReadOnlySpan rest) + private Http2ResponseWriter ParkRest(int streamId, ReadOnlySpan rest) { Http2ResponseWriter writer = RentWriter(streamId); writer.ContinueBody(); rest.CopyTo(writer.GetSpan(rest.Length)); writer.Advance(rest.Length); - - _ = CompleteParkedAsync(writer); - } - - private async Task CompleteParkedAsync(Http2ResponseWriter writer) - { - try - { - await writer.CompleteAsync(); - } - catch - { - // FlushAsync has already marked the connection broken; the read loop sees it. - } - finally - { - _creditWaiters.Remove(writer.StreamId); - _responseWindows.Remove(writer.StreamId); - _writerPool.Push(writer); - } + return writer; } // Three ASCII digits: HTTP/2 has no reason phrase and every valid status is 100..599. diff --git a/src/protocols/ioxide.http2/Http2Connection.cs b/src/protocols/ioxide.http2/Http2Connection.cs index 1a2a338d..7bf8fb63 100644 --- a/src/protocols/ioxide.http2/Http2Connection.cs +++ b/src/protocols/ioxide.http2/Http2Connection.cs @@ -1,5 +1,6 @@ using System.Buffers; using System.IO.Pipelines; +using System.Runtime.CompilerServices; namespace ioxide.http2; @@ -331,13 +332,14 @@ private void DispatchBuffered(Func> handl // there is no Task to allocate. if (inFlight.IsCompletedSuccessfully) { + Http2ResponseWriter? parked = null; try { - WriteResponse(pending.StreamId, inFlight.Result); + parked = WriteResponse(pending.StreamId, inFlight.Result); } finally { - RetireStream(pending); + Retire(pending, parked); } continue; } @@ -358,11 +360,12 @@ private void DispatchBuffered(Func> handl /// private async Task CompleteBufferedAsync(ValueTask inFlight, Http2Request request, PendingRequest pending) { + Http2ResponseWriter? parked = null; try { Http2Response response = await inFlight; await new ReactorSwitch(_reactor); // back on the reactor, wherever the handler finished - WriteResponse(pending.StreamId, response); + parked = WriteResponse(pending.StreamId, response); } catch (Exception exception) { @@ -373,12 +376,12 @@ private async Task CompleteBufferedAsync(ValueTask inFlight, Http if (!IsBroken) { - WriteResponse(pending.StreamId, new Http2Response { Status = 500 }); + WriteResponse(pending.StreamId, new Http2Response { Status = 500 }); // no body, so nothing parks } } finally { - RetireStream(pending); + Retire(pending, parked); await MaybeFlushAsync(); } } @@ -418,7 +421,7 @@ private void RetireStream(PendingRequest pending) // Every reset takes the stream out of _streams; short of one, a streamed writer has staged END_STREAM. bool live = _streams.Remove(pending.StreamId) && !IsBroken; - // A buffered rest parked on credit keeps its window: its END_STREAM is still to go. + // A response parked on credit keeps its window: its END_STREAM is still to go. bool reset = live && !pending.RequestEnded && !_responseWindows.ContainsKey(pending.StreamId); if (reset) @@ -435,6 +438,68 @@ private void RetireStream(PendingRequest pending) } } + // A handler is done with its stream: retired now, unless the rest of its response waits on credit in a writer. + private void Retire(PendingRequest pending, Http2ResponseWriter? parked) + { + if (parked is null) + { + RetireStream(pending); + } + else + { + RetireAfterEnd(parked, pending); + } + } + + /// + /// A handler is done, and the end of its response waits on the peer's credit. Its stream stays open behind it: + /// a request still arriving is drained meanwhile, credited and dropped, since a client that reads its response + /// only once its upload has ended credits nothing before then. The stream is retired once the end is out, and + /// reset with NO_ERROR after it if the request is still arriving then (RFC 9113 8.1). + /// + [MethodImpl(MethodImplOptions.NoInlining)] + private void RetireAfterEnd(Http2ResponseWriter writer, PendingRequest pending) + { + PendingRequest? open = null; + if (!IsBroken && _streams.ContainsKey(pending.StreamId)) + { + pending.BodyReader?.Drop(); // credits what the handler left unread, and DATA still to come as it lands + open = pending; + } + else + { + RetireStream(pending); // reset, broken, or a whole body that left _streams once it arrived: no stream to hold open + } + + _ = FinishParkedAsync(writer, open); + } + + private async Task FinishParkedAsync(Http2ResponseWriter writer, PendingRequest? open) + { + try + { + await writer.CompleteAsync(); // a buffered rest starts here; a streamed handler's writer has completed already + if (writer.ParkedEnd is { } end) + { + await end; + } + } + catch + { + // FlushAsync has already marked the connection broken; the read loop sees it. + } + finally + { + _creditWaiters.Remove(writer.StreamId); + _responseWindows.Remove(writer.StreamId); + if (open is not null) + { + RetireStream(open); + } + _writerPool.Push(writer); + } + } + // Kept unless the pool is full or a peer's header lines grew its lists; only the reactor rents. private void Recycle(PendingRequest pending) { @@ -445,7 +510,7 @@ private void Recycle(PendingRequest pending) } } - // Ended before its request did: without a body reader it was never dispatched; with one, its handler retires it. + // Ended before its request did: without a body reader it was never dispatched; with one, its handler or the response it left on credit retires it. private void Discard(PendingRequest pending) { if (pending.BodyReader is null) diff --git a/src/protocols/ioxide.http2/Http2ResponseWriter.cs b/src/protocols/ioxide.http2/Http2ResponseWriter.cs index 3ebd5c49..fbd0d77f 100644 --- a/src/protocols/ioxide.http2/Http2ResponseWriter.cs +++ b/src/protocols/ioxide.http2/Http2ResponseWriter.cs @@ -55,9 +55,15 @@ internal Http2ResponseWriter(Http2Connection connection, int streamId) /// The stream this response belongs to. public int StreamId => _streamId; - /// True once the response has ended: its body finished and END_STREAM sent, or its stream reset by . + /// + /// True once the response has ended: has returned, its END_STREAM sent or left to + /// the connection to send as the peer's credit allows, or has reset its stream. + /// public bool IsCompleted => _completed; + /// The rest of a completed response and its END_STREAM, still waiting on the peer's credit; the stream is retired behind it. + internal Task? ParkedEnd { get; private set; } + /// /// Send the response headers. Exactly once, before any body byte - HTTP/2 puts HEADERS ahead /// of DATA and there is no correcting it later. @@ -160,8 +166,8 @@ public void Advance(int count) /// growing a queue behind it. /// /// - /// once the peer has reset the stream or the connection is - /// gone, as a TCP pipe writer reports a closed peer: nothing written from then on reaches anyone. + /// once the response has ended, the peer has reset the stream or the + /// connection is gone, as a TCP pipe writer reports a closed peer: nothing written from then on reaches anyone. /// /// Each call has to complete before the next one is made. public ValueTask FlushAsync() => FlushCore(endStream: false); @@ -169,6 +175,10 @@ public void Advance(int count) /// /// Send what is left and mark END_STREAM. A handler that returns without calling this gets it /// called for it - the peer is owed an end either way. + /// + /// It does not wait for the peer's credit, as does: what the peer's windows cannot + /// take yet is left to the connection, which sends it, END_STREAM last, as credit arrives. A client that reads + /// its response only once its upload has ended gives that credit only then, and the handler is not held until it does. /// public async ValueTask CompleteAsync() { @@ -185,10 +195,10 @@ public async ValueTask CompleteAsync() await FlushCore(endStream: true); _completed = true; - if (_staging.Length > 0) + // A parked end sends from the staging still, and gives it back once it is out. + if (ParkedEnd is null) { - ArrayPool.Shared.Return(_staging); - _staging = []; + ReleaseStaging(); } } @@ -204,8 +214,8 @@ public async ValueTask CompleteAsync() /// no longer wanted rather than one that failed. /// /// - /// Once the response has completed, the peer has reset the stream or the connection is gone, it - /// sends nothing. Either way the response has ended: is true, + /// Once the response has completed, its end left to the connection included, the peer has reset the stream or + /// the connection is gone, it sends nothing. Either way the response has ended: is true, /// reports the peer gone, and nothing more is sent when the handler /// returns. The request body ends with the stream: a read on it, parked or still to come, raises /// as for a body cut off. Before the headers it resets the stream too; a handler that wants a @@ -270,7 +280,7 @@ internal ValueTask FailAsync() private ValueTask FlushCore(bool endStream) { var onReactor = new ReactorSwitch(_connection.Reactor); - if (!_headersSent || !onReactor.IsCompleted) + if (_completed || !_headersSent || !onReactor.IsCompleted) // completed: a parked end still sends from the staging { return FlushCoreAsync(endStream); } @@ -323,11 +333,36 @@ private ValueTask Send(bool endStream) return SendStaged(endStream, ref sent) switch { Progress.Sent => Finish(endStream, sent), + Progress.Stalled when endStream => Park(sent), Progress.Stalled => SendAfterCreditAsync(endStream, sent), _ => new ValueTask(PeerGone), }; } + // The end out of credit goes on without its caller, which a client crediting only after its upload would hold for good. + [MethodImpl(MethodImplOptions.NoInlining)] + private ValueTask Park(int sent) + { + ParkedEnd = EndAfterCreditAsync(sent); + return default; + } + + private async Task EndAfterCreditAsync(int sent) + { + try + { + await SendAfterCreditAsync(endStream: true, sent); + } + catch + { + // FlushAsync has already marked the connection broken; the read loop sees it. + } + finally + { + ReleaseStaging(); + } + } + // Everything staged from `sent` on, as far as credit allows. private Progress SendStaged(bool endStream, ref int sent) { @@ -452,6 +487,15 @@ private void EnsureStaging(int sizeHint) _staging = grown; } + private void ReleaseStaging() + { + if (_staging.Length > 0) + { + ArrayPool.Shared.Return(_staging); + _staging = []; + } + } + /// Carry on a buffered response whose headers are already out, for the body its windows could not take. internal void ContinueBody() => _headersSent = true; @@ -464,5 +508,6 @@ internal void Reset(int streamId) _headersSent = false; _completed = false; _unsent = null; + ParkedEnd = null; } } diff --git a/tests/Ioxide.Tests.E2E/Protocols/EarlyAnswerTests.cs b/tests/Ioxide.Tests.E2E/Protocols/EarlyAnswerTests.cs index 66b904de..cff9777b 100644 --- a/tests/Ioxide.Tests.E2E/Protocols/EarlyAnswerTests.cs +++ b/tests/Ioxide.Tests.E2E/Protocols/EarlyAnswerTests.cs @@ -16,10 +16,13 @@ internal static class EarlyAnswerTests // A control's upload, read whole by its handler. private const long ReadUpload = 8L << 20; - // Measured stops are 64 KiB on h2, the connection window, and 192 KiB on h3; these leave room for a slow box. + // Measured stops are up to 320 KiB on h2, the stream window and what the client had buffered, and 192 KiB on h3; these leave room for a slow box. private const long H2Stopped = 512L << 10; private const long H3Stopped = 1L << 20; + // A duplex upload is credited while the answer waits on the client's credit, so it stops later: measured up to 2.5 MiB. + private const long H2DrainedStopped = 32L << 20; + // What the raw client offers to upload after the request's headers: past it, nothing stopped the upload. private const long RawBudget = 4L << 20; @@ -28,9 +31,69 @@ internal static class EarlyAnswerTests public static void Register(Runner runner) { RegisterHttpClient(runner); + RegisterPastWindow(runner); RegisterRawClient(runner); } + // Past the client's 64 KiB stream window, which this client credits only once its upload ends: the unread upload has to be credited first. + private static void RegisterPastWindow(Runner runner) + { + byte[] answer = Pattern(256 * 1024); + + runner.Test("h2 early answer: a streamed 413 past the client's window, its handler returning CompleteAsync, arrives whole, and the upload ends", () => + { + int port = StartH2(connection => connection.RunAsync((_, _, writer) => AnswerAsync(writer, answer))); + using HttpClient client = H2Client(); + var upload = new CountedUpload(Upload); + AssertAnsweredAndEnded(PostAsync(client, $"http://127.0.0.1:{port}/", upload), upload, answer); + }); + + runner.Test("h2 early answer: a streamed 413 past the client's window, left to the stack to complete, arrives whole, and the upload ends", () => + { + int port = StartH2(connection => connection.RunAsync((_, _, writer) => + { + writer.WriteHeaders(new Http2Response { Status = 413 }); + writer.Write(answer); + return default; + })); + using HttpClient client = H2Client(); + var upload = new CountedUpload(Upload); + AssertAnsweredAndEnded(PostAsync(client, $"http://127.0.0.1:{port}/", upload), upload, answer); + }); + + runner.Test("h2 early answer: a buffered 413 past the client's window, returned once the upload has stalled, arrives whole, and the upload ends", () => + { + var stalled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + int port = StartH2(connection => connection.RunAsync(async (_, _) => + { + await stalled.Task; + return new Http2Response { Status = 413, Body = answer }; + })); + using HttpClient client = H2Client(); + var upload = new CountedUpload(Upload); + Task<(HttpStatusCode Status, byte[] Body)> answered = PostAsync(client, $"http://127.0.0.1:{port}/", upload); + + WaitStalled(upload); + Assert.True(upload.Sent < Upload, $"precondition: the upload was meant to stall on the window its unread body was given, not run to {upload.Sent} bytes"); + stalled.SetResult(); + AssertAnsweredAndEnded(answered, upload, answer); + }); + + foreach (bool streamed in new[] { false, true }) + { + bool stream = streamed; + runner.Test($"h2 early answer: a {(stream ? "streamed" : "buffered")} 413 past the client's window to a duplex upload arrives whole, and the upload stops", () => + { + // This client credits the answer as it uploads; once the answer has ended, the reset after it stops the upload. + int port = StartH2(connection => stream + ? connection.RunAsync((_, _, writer) => AnswerAsync(writer, answer)) + : connection.RunAsync((_, _) => new ValueTask(new Http2Response { Status = 413, Body = answer }))); + using HttpClient client = H2Client(); + AssertAnsweredAndStopped(client, $"http://127.0.0.1:{port}/", answer, H2DrainedStopped, duplex: true); + }); + } + } + private static void RegisterHttpClient(Runner runner) { // Inside the client's 64 KiB stream window: this client credits an answer only once its upload ends, and the reset follows the END_STREAM. @@ -191,20 +254,56 @@ private static void RegisterRawClient(Runner runner) }); } - private static void AssertAnsweredAndStopped(HttpClient client, string url, byte[] answer, long stopped) + private static void AssertAnsweredAndStopped(HttpClient client, string url, byte[] answer, long stopped, bool duplex = false) { - var upload = new CountedUpload(Upload); + HttpContent upload = duplex ? new DuplexUpload(Upload) : new CountedUpload(Upload); Task<(HttpStatusCode Status, byte[] Body)> answered = PostAsync(client, url, upload); Assert.True(answered.Wait(100_000), "the answer never arrived"); Assert.Equal(HttpStatusCode.RequestEntityTooLarge, answered.Result.Status); AssertBody(answer, answered.Result.Body); - long sent = upload.Ended.Result; + long sent = ((ICountedUpload)upload).Ended.Result; Assert.True(sent < stopped, $"the client uploaded {sent} of {Upload} bytes to a handler that read none of them: nothing asked it to stop"); } + // A client that reads the answer only once its upload has ended gets the answer whole, its upload taken to the end. + private static void AssertAnsweredAndEnded(Task<(HttpStatusCode Status, byte[] Body)> answered, CountedUpload upload, byte[] answer) + { + try + { + Assert.True(answered.Wait(100_000), $"the answer never arrived; the upload is at {upload.Sent} of {Upload} bytes"); + } + catch (AggregateException exception) + { + throw new Exception($"the answer never arrived ({exception.GetBaseException().Message}); the upload is at {upload.Sent} of {Upload} bytes"); + } + Assert.Equal(HttpStatusCode.RequestEntityTooLarge, answered.Result.Status); + AssertBody(answer, answered.Result.Body); + Assert.Equal(Upload, upload.Ended.Result); + } + + // Until what the client takes from its source stops growing: an unread upload filled the window it was given. + private static void WaitStalled(CountedUpload upload) + { + long last = -1, since = Environment.TickCount64, deadline = since + 30_000; + while (Environment.TickCount64 < deadline) + { + long now = upload.Sent; + if (now != last) + { + (last, since) = (now, Environment.TickCount64); + } + else if (now > 0 && Environment.TickCount64 - since > 500) + { + return; + } + Thread.Sleep(20); + } + throw new Exception($"the upload never stalled: it went on to {upload.Sent} bytes"); + } + private static void AssertReadWhole(HttpClient client, string url) { var upload = new CountedUpload(ReadUpload); @@ -217,17 +316,18 @@ private static void AssertReadWhole(HttpClient client, string url) } // The answer, once the upload has ended as well: at its last byte, or where the client gave up on the rest. - private static async Task<(HttpStatusCode Status, byte[] Body)> PostAsync(HttpClient client, string url, CountedUpload upload) + private static async Task<(HttpStatusCode Status, byte[] Body)> PostAsync(HttpClient client, string url, HttpContent upload) { + var counted = (ICountedUpload)upload; try { using HttpResponseMessage response = await client.PostAsync(url, upload); byte[] body = await response.Content.ReadAsByteArrayAsync(); // Held open until then: disposing it would have the client cancel the upload itself. - if (await Task.WhenAny(upload.Ended, Task.Delay(30_000)) != upload.Ended) + if (await Task.WhenAny(counted.Ended, Task.Delay(30_000)) != counted.Ended) { - throw new Exception($"the upload neither finished nor stopped, at {upload.Sent} bytes"); + throw new Exception($"the upload neither finished nor stopped, at {counted.Sent} bytes"); } return (response.StatusCode, body); } @@ -372,8 +472,15 @@ private static byte[] Pattern(int length) return bytes; } - // A StreamContent, so not duplex: over HTTP/3 the client finishes its upload before it hands over the answer. - private sealed class CountedUpload : StreamContent + private interface ICountedUpload + { + long Sent { get; } + + Task Ended { get; } + } + + // A StreamContent, so not duplex: the client finishes its upload before it hands over the answer, and over HTTP/2 credits the answer only then. + private sealed class CountedUpload : StreamContent, ICountedUpload { private readonly Source _source; private readonly TaskCompletionSource _ended = new(TaskCreationOptions.RunContinuationsAsynchronously); @@ -406,6 +513,41 @@ protected override async Task SerializeToStreamAsync(Stream stream, TransportCon } } + // An HttpContent of its own, which SocketsHttpHandler sends duplex: the answer is handed over, and credited, while the upload goes on. + private sealed class DuplexUpload(long length) : HttpContent, ICountedUpload + { + private long _sent; + private readonly TaskCompletionSource _ended = new(TaskCreationOptions.RunContinuationsAsynchronously); + + public long Sent => Interlocked.Read(ref _sent); + + public Task Ended => _ended.Task; + + protected override async Task SerializeToStreamAsync(Stream stream, TransportContext? context) + { + byte[] chunk = new byte[64 * 1024]; + try + { + while (Sent < length) + { + int count = (int)Math.Min(chunk.Length, length - Sent); + await stream.WriteAsync(chunk.AsMemory(0, count)); + Interlocked.Add(ref _sent, count); + } + } + finally + { + _ended.TrySetResult(Sent); + } + } + + protected override bool TryComputeLength(out long size) + { + size = length; + return true; + } + } + // Zeros, as many as the upload is long, counted as they are taken. private sealed class Source(long size) : Stream { diff --git a/tests/Ioxide.Tests.Unit/Http2EarlyAnswerParkedTests.cs b/tests/Ioxide.Tests.Unit/Http2EarlyAnswerParkedTests.cs new file mode 100644 index 00000000..08664e97 --- /dev/null +++ b/tests/Ioxide.Tests.Unit/Http2EarlyAnswerParkedTests.cs @@ -0,0 +1,228 @@ +using System.Buffers; +using System.Runtime.CompilerServices; +using ioxide.http2; +using static Ioxide.Tests.Http2EarlyAnswerTests; +using static Ioxide.Tests.Http2FlowControlTests; + +namespace Ioxide.Tests; + +/// +/// An early answer past the client's stream window, to an upload its handler did not read: a client that credits the +/// answer only once its upload has ended needs the upload credited first. The handler is not held on that credit, what +/// it left unread is credited and dropped once it returns, and RST_STREAM(NO_ERROR) follows the answer's END_STREAM if +/// the upload is still arriving then (RFC 9113 8.1). +/// +internal static class Http2EarlyAnswerParkedTests +{ + // The client's stream window, as it is until its SETTINGS say otherwise; the answer is twice that, so it parks. + private const int ClientWindow = 65535; + private const int AnswerLength = 2 * ClientWindow; + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_writerPool")] + private static extern ref Stack WriterPool(Http2Connection connection); + + public static void Register(Runner runner) + { + RegisterDrain(runner); + RegisterReset(runner); + } + + private static void RegisterDrain(Runner runner) + { + runner.Test("h2 early answer: a buffered answer past the client's window, returned once the upload filled its stream window, credits what it left unread", () => + { + var stalled = new TaskCompletionSource(); + + using var client = new StrictClient(); + Task run = client.Connection.RunAsync(async (_, _) => + { + await stalled.Task; + return new Http2Response { Status = 413, Body = new byte[AnswerLength] }; + }); + + client.ReleaseFlush(); + client.Feed([.. Open(), .. Post(1), .. Fill(1, StreamWindow)]); + Assert.Equal(0, Credit(client.Drain(), 1)); // unread, so not credited yet + + stalled.SetResult(); // answered outside the pass, the upload stalled + List frames = client.Drain(); + Assert.Equal(ClientWindow, Frame.Body(frames, 1).Length); // one client window of the answer, then parked + int credited = Credit(frames, 1); + Assert.True(credited == StreamWindow, + $"the handler returned with {StreamWindow} bytes unread and {credited} came back on its stream: a client that credits the answer only once its upload ends has no window left to end it"); + + AssertUploadEndsThenAnswerEnds(client, frames); + client.Close(run); + }); + + runner.Test("h2 early answer: CompleteAsync past the client's window returns without its credit, and the unread upload is credited once the handler returns", () => + { + bool returned = false; + + using var client = new StrictClient(); + Task run = client.Connection.RunAsync(async (_, _, writer) => + { + writer.WriteHeaders(new Http2Response { Status = 413 }); + writer.Write(new byte[AnswerLength]); + await writer.CompleteAsync(); + returned = writer.IsCompleted; + }); + + client.ReleaseFlush(); + client.Feed([.. Open(), .. Post(1), .. Fill(1, StreamWindow)]); + List frames = client.Drain(); + Assert.True(returned, "CompleteAsync held the handler on credit that a client reading its answer only once its upload ends gives only then"); + Assert.Equal(ClientWindow, Frame.Body(frames, 1).Length); + int credited = Credit(frames, 1); + Assert.True(credited == StreamWindow, + $"the handler returned with {StreamWindow} bytes unread and {credited} came back on its stream"); + + AssertUploadEndsThenAnswerEnds(client, frames); + client.Close(run); + }); + + runner.Test("h2 early answer: a streamed answer past the client's window that its handler leaves the stack to complete credits the unread upload", () => + { + using var client = new StrictClient(); + Task run = client.Connection.RunAsync((_, _, writer) => + { + writer.WriteHeaders(new Http2Response { Status = 413 }); + writer.Write(new byte[AnswerLength]); + return default; + }); + + client.ReleaseFlush(); + client.Feed([.. Open(), .. Post(1), .. Fill(1, StreamWindow)]); + List frames = client.Drain(); + Assert.Equal(ClientWindow, Frame.Body(frames, 1).Length); + int credited = Credit(frames, 1); + Assert.True(credited == StreamWindow, + $"the handler returned with {StreamWindow} bytes unread and {credited} came back on its stream"); + + AssertUploadEndsThenAnswerEnds(client, frames); + client.Close(run); + }); + + runner.Test("h2 early answer: a handler that reads its body after CompleteAsync parked its answer gets all of it", () => + { + // Only a handler that has returned is done with its body: nothing is drained from under one still reading. + var read = new Tally(); + + using var client = new StrictClient(); + Task run = client.Connection.RunAsync(async (_, body, writer) => + { + writer.WriteHeaders(new Http2Response { Status = 413 }); + writer.Write(new byte[AnswerLength]); + await writer.CompleteAsync(); + await ReadAll(body, read); + }); + + client.ReleaseFlush(); + client.Feed([.. Open(), .. Post(1), .. Fill(1, StreamWindow)]); + List frames = client.Drain(); + Assert.True(read.Bytes == StreamWindow, $"the handler read {read.Bytes} of the {StreamWindow} bytes sent with its request, its answer parked"); + Assert.Equal(StreamWindow, Credit(frames, 1)); // credited as read, once + + client.Feed(Data(1, 0, endStream: true)); // the handler reads to the end and returns + client.Feed([.. WindowUpdate(0, 1 << 20), .. WindowUpdate(1, 1 << 20)]); + frames.AddRange(client.Drain()); + Assert.Equal(AnswerLength, Frame.Body(frames, 1).Length); + Assert.True(!frames.Any(f => f.Type == RstStreamFrame), "a stream whose request had ended was reset"); + + client.Close(run); + }); + + runner.Test("h2 early answer: a FlushAsync after CompleteAsync parked the answer reports it ended, and the answer goes out once", () => + { + // The parked end sends from the writer's staging: a flush that took it up again would wait on the same credit, and send it twice. + string? flushed = null; + + using var client = new StrictClient(); + Task run = client.Connection.RunAsync(async (_, _, writer) => + { + writer.WriteHeaders(new Http2Response { Status = 413 }); + writer.Write(new byte[AnswerLength]); + await writer.CompleteAsync(); + flushed = (await writer.FlushAsync()).IsCompleted ? "ended" : "not ended"; + }); + + client.ReleaseFlush(); + client.Feed([.. Open(), .. Post(1), .. Data(1, 1000, endStream: false)]); + List frames = client.Drain(); + Assert.True(flushed == "ended", $"a flush after the response had completed returned {flushed ?? "nothing, still waiting on credit"}"); + + client.Feed([.. WindowUpdate(0, 1 << 20), .. WindowUpdate(1, 1 << 20)]); + frames.AddRange(client.Drain()); + Assert.Equal(AnswerLength, Frame.Body(frames, 1).Length); + Assert.Equal(1, frames.Count(f => f.StreamId == 1 && f.EndStream)); + + client.Close(run); + }); + + runner.Test("h2 early answer: a streamed answer parked on credit lets go of its writer when the client closes the connection", () => + { + using var client = new StrictClient(); + Task run = client.Connection.RunAsync((_, _, writer) => + { + writer.WriteHeaders(new Http2Response { Status = 413 }); + writer.Write(new byte[AnswerLength]); + return writer.CompleteAsync(); + }); + + client.ReleaseFlush(); + client.Feed([.. Open(), .. Post(1), .. Data(1, 1000, endStream: false)]); + Assert.Equal(ClientWindow, Frame.Body(client.Drain(), 1).Length); + Assert.True(WriterPool(client.Connection).Count == 0, "precondition: the answer was meant to be parked, its writer out"); + + client.Close(run); + Assert.True(WriterPool(client.Connection).Count == 1, "the connection ended with the parked answer still holding its writer"); + }); + } + + private static void RegisterReset(Runner runner) + { + foreach (bool streamed in new[] { false, true }) + { + bool stream = streamed; + runner.Test($"h2 early answer: a {(stream ? "streamed" : "buffered")} answer parked on credit, its END_STREAM out with the upload still arriving, is followed by RST_STREAM(NO_ERROR)", () => + { + // A client that reads while it uploads credits the answer; once it has ended, the upload is asked to stop. + string answer = new('x', AnswerLength); + + using var client = new StrictClient(); + Task run = stream + ? client.Connection.RunAsync((_, _, writer) => Answer(writer, answer)) + : client.Connection.RunAsync((_, _) => new ValueTask(Http2Response.Text(answer, 413))); + + client.ReleaseFlush(); + client.Feed([.. Open(), .. Post(1), .. Data(1, 1000, endStream: false)]); + List frames = client.Drain(); + Assert.Equal(ClientWindow, Frame.Body(frames, 1).Length); + + client.Feed([.. Data(1, 16384, endStream: false), .. WindowUpdate(0, 1 << 20), .. WindowUpdate(1, 1 << 20)]); + frames.AddRange(client.Drain()); + AssertAnsweredThenStopped(frames, streamId: 1, 413, answer); + Assert.Equal(1000 + 16384, Credit(frames, 1)); // drained while the answer waited + + client.Close(run); + }); + } + } + + // The upload goes on with the credit the drain gave it, then ends; credited, the answer then ends whole, and no reset follows. + private static void AssertUploadEndsThenAnswerEnds(StrictClient client, List frames) + { + client.Feed(Data(1, 16384, endStream: false)); + int credited = Credit(client.Drain(), 1); + Assert.True(credited == 16384, $"16384 more bytes of the unread upload arrived and {credited} were credited"); + + client.Feed([.. Data(1, 16384, endStream: true), .. WindowUpdate(0, 1 << 20), .. WindowUpdate(1, 1 << 20)]); + List after = client.Drain(); + frames.AddRange(after); + Assert.Equal(0, Credit(after, 1)); // an ended request is owed none + + Assert.Equal(AnswerLength, Frame.Body(frames, 1).Length); + Assert.True(frames.Last(f => f.StreamId == 1).EndStream, "the answer never ended"); + Assert.True(!frames.Any(f => f.Type == RstStreamFrame), "a stream whose request had ended was reset"); + } +} diff --git a/tests/Ioxide.Tests.Unit/Http2FlowControlTests.cs b/tests/Ioxide.Tests.Unit/Http2FlowControlTests.cs index 7737476c..d19826a4 100644 --- a/tests/Ioxide.Tests.Unit/Http2FlowControlTests.cs +++ b/tests/Ioxide.Tests.Unit/Http2FlowControlTests.cs @@ -272,7 +272,9 @@ await ReadAll(body, read, between: () => using var client = new StrictClient(); Task run = client.Connection.RunAsync(async (_, writer) => { - await AnswerWith(writer, new byte[64 * 1024]); + writer.WriteHeaders(new Http2Response { Status = 200 }); + writer.Write(new byte[64 * 1024]); + await writer.FlushAsync(); // waits on credit, where CompleteAsync leaves it to the connection finished = true; }); diff --git a/tests/Ioxide.Tests.Unit/Program.cs b/tests/Ioxide.Tests.Unit/Program.cs index bba8de8b..db3ffe68 100644 --- a/tests/Ioxide.Tests.Unit/Program.cs +++ b/tests/Ioxide.Tests.Unit/Program.cs @@ -43,6 +43,7 @@ private static int Main() Http2BufferedCreditTests.Register(runner); Http2EarlyAnswerTests.Register(runner); Http2EarlyAnswerGuardTests.Register(runner); + Http2EarlyAnswerParkedTests.Register(runner); Nghttp2ResetResponseTests.Register(runner); Http2PeerClosedFlushTests.Register(runner); Http2StreamResetTests.Register(runner);