Track advertised receive window synchronously in initiate/5

Streams opened before the server's SETTINGS ACK arrived were reading
their initial receive window from `conn.client_settings`, which still
held library defaults at that point. If the user advertised a stream
window smaller than the default (e.g. `initial_window_size: 65_535`),
the stream struct tracked the 4 MB default locally while the server
respected the 65_535 we sent in SETTINGS. The client's remaining
window never dropped to the refill threshold, stream-level
WINDOW_UPDATE frames never fired, and the connection stalled once the
server exhausted its per-stream send window.

Mirror the advertised `client_settings_params` into
`conn.client_settings` during `initiate/5` — the sender already knows
what it committed to and doesn't need to wait for the ACK to act on
it. Add a regression test that opens a stream before the ACK round
trip and asserts the stream struct reflects the advertised value.

Also rename `receive_window` to `receive_window_remaining` so the
peak/remaining distinction is clear at the call site, and document
that `:receive_window_update_threshold` is shared between the
connection and per-stream windows (so windows at or below the
threshold refill on every DATA frame).

Author: ericmj

lib/mint/http.ex

@@ -247,7 +247,10 @@ defmodule Mint.HTTP do
       window that must remain on a connection or stream before a `WINDOW_UPDATE`
       frame is sent to refill it. Lower values send more frequent, smaller updates;
       higher values batch updates into fewer, larger ones. Defaults to 160_000
-      (approximately 10× the default max frame size).
+      (approximately 10× the default max frame size). The same threshold applies
+      to both the connection and per-stream windows; when a window's peak size is
+      at or below the threshold, the client refills after every DATA frame on
+      that window.
 
   There may be further protocol specific options that only take effect when the corresponding
   connection is established. Check `Mint.HTTP1.connect/4` and `Mint.HTTP2.connect/4` for

lib/mint/http2.ex

@@ -195,12 +195,12 @@ defmodule Mint.HTTP2 do
     # matching WINDOW_UPDATE to bring the server's view from the spec
     # default of 65_535 up to the advertised peak.
     receive_window_size: @default_window_size,
-    # `receive_window` is the server's current view of our receive
+    # `receive_window_remaining` is the server's current view of our receive
     # window — decremented by DATA frame sizes as they arrive, bumped
     # back up to `receive_window_size` whenever we send a
     # WINDOW_UPDATE. When it drops to `receive_window_update_threshold`, we
     # refill it back to the peak in one frame.
-    receive_window: @default_window_size,
+    receive_window_remaining: @default_window_size,
     # Minimum remaining receive window before we send a WINDOW_UPDATE.
     # Configurable via the `:receive_window_update_threshold` connect option.
     receive_window_update_threshold: @default_receive_window_update_threshold,
@@ -912,7 +912,7 @@ defmodule Mint.HTTP2 do
   def set_window_size(%__MODULE__{} = conn, :connection, new_size) do
     do_set_window_size(conn, 0, conn.receive_window_size, new_size, fn conn, size ->
       conn = put_in(conn.receive_window_size, size)
-      put_in(conn.receive_window, size)
+      put_in(conn.receive_window_remaining, size)
     end)
   catch
     :throw, {:mint, conn, error} -> {:error, conn, error}
@@ -925,7 +925,7 @@ defmodule Mint.HTTP2 do
 
         do_set_window_size(conn, stream_id, current, new_size, fn conn, size ->
           conn = put_in(conn.streams[stream_id].receive_window_size, size)
-          put_in(conn.streams[stream_id].receive_window, size)
+          put_in(conn.streams[stream_id].receive_window_remaining, size)
         end)
 
       :error ->
@@ -935,7 +935,8 @@ defmodule Mint.HTTP2 do
     :throw, {:mint, conn, error} -> {:error, conn, error}
   end
 
-  defp do_set_window_size(conn, _stream_id, current, new_size, _update) when new_size == current do
+  defp do_set_window_size(conn, _stream_id, current, new_size, _update)
+       when new_size == current do
     {:ok, conn}
   end
 
@@ -1121,9 +1122,19 @@ defmodule Mint.HTTP2 do
     scheme_string = Atom.to_string(scheme)
     mode = Keyword.get(opts, :mode, :active)
     log? = Keyword.get(opts, :log, false)
-    connection_window_size = Keyword.get(opts, :connection_window_size, @default_connection_window_size)
+
+    connection_window_size =
+      Keyword.get(opts, :connection_window_size, @default_connection_window_size)
+
     validate_window_size!(:connection_window_size, connection_window_size)
-    receive_window_update_threshold = Keyword.get(opts, :receive_window_update_threshold, @default_receive_window_update_threshold)
+
+    receive_window_update_threshold =
+      Keyword.get(
+        opts,
+        :receive_window_update_threshold,
+        @default_receive_window_update_threshold
+      )
+
     validate_receive_window_update_threshold!(receive_window_update_threshold)
     client_settings_params = Keyword.get(opts, :client_settings, [])
 
@@ -1160,10 +1171,21 @@ defmodule Mint.HTTP2 do
       state: :handshaking,
       log: log?,
       receive_window_size: connection_window_size,
-      receive_window: connection_window_size,
+      receive_window_remaining: connection_window_size,
       receive_window_update_threshold: receive_window_update_threshold
     }
 
+    # Mirror the advertised client settings into `conn.client_settings` up
+    # front. Streams opened before the server's SETTINGS ACK arrives read
+    # their initial receive window from this map; without this, they would
+    # track the library default instead of the value we actually sent in
+    # the SETTINGS frame, and stream-level WINDOW_UPDATEs would never fire
+    # when the advertised window is smaller than the default.
+    conn =
+      update_in(conn.client_settings, fn settings ->
+        Enum.into(client_settings_params, settings)
+      end)
+
     preface = build_preface(client_settings_params, connection_window_size)
 
     with :ok <- Util.inet_opts(transport, socket),
@@ -1286,7 +1308,7 @@ defmodule Mint.HTTP2 do
       receive_window_size: conn.client_settings.initial_window_size,
       # Current remaining receive window for this stream, tracked
       # independently from the peak so that refills can be batched.
-      receive_window: conn.client_settings.initial_window_size,
+      receive_window_remaining: conn.client_settings.initial_window_size,
       received_first_headers?: false
     }
 
@@ -1417,10 +1439,14 @@ defmodule Mint.HTTP2 do
 
     cond do
       data_size > stream.send_window_size ->
-        throw({:mint, conn, wrap_error({:exceeds_window_size, :request, stream.send_window_size})})
+        throw(
+          {:mint, conn, wrap_error({:exceeds_window_size, :request, stream.send_window_size})}
+        )
 
       data_size > conn.send_window_size ->
-        throw({:mint, conn, wrap_error({:exceeds_window_size, :connection, conn.send_window_size})})
+        throw(
+          {:mint, conn, wrap_error({:exceeds_window_size, :connection, conn.send_window_size})}
+        )
 
       # If the data size is greater than the max frame size, we chunk automatically based
       # on the max frame size.
@@ -1790,12 +1816,12 @@ defmodule Mint.HTTP2 do
   # roughly one update per `(receive_window_size - threshold)` bytes
   # consumed.
   defp refill_client_windows(conn, stream_id, data_size) do
-    conn = update_in(conn.receive_window, &(&1 - data_size))
+    conn = update_in(conn.receive_window_remaining, &(&1 - data_size))
 
     conn =
       case Map.fetch(conn.streams, stream_id) do
         {:ok, _stream} ->
-          update_in(conn.streams[stream_id].receive_window, &(&1 - data_size))
+          update_in(conn.streams[stream_id].receive_window_remaining, &(&1 - data_size))
 
         :error ->
           conn
@@ -1815,8 +1841,8 @@ defmodule Mint.HTTP2 do
   end
 
   defp maybe_refill_conn(frames, conn) do
-    if conn.receive_window <= conn.receive_window_update_threshold do
-      increment = conn.receive_window_size - conn.receive_window
+    if conn.receive_window_remaining <= conn.receive_window_update_threshold do
+      increment = conn.receive_window_size - conn.receive_window_remaining
       [window_update(stream_id: 0, window_size_increment: increment) | frames]
     else
       frames
@@ -1826,8 +1852,8 @@ defmodule Mint.HTTP2 do
   defp maybe_refill_stream(frames, conn, stream_id) do
     case Map.fetch(conn.streams, stream_id) do
       {:ok, stream} ->
-        if stream.receive_window <= conn.receive_window_update_threshold do
-          increment = stream.receive_window_size - stream.receive_window
+        if stream.receive_window_remaining <= conn.receive_window_update_threshold do
+          increment = stream.receive_window_size - stream.receive_window_remaining
 
           [
             window_update(stream_id: stream_id, window_size_increment: increment) | frames
@@ -1844,11 +1870,11 @@ defmodule Mint.HTTP2 do
   defp apply_refills(conn, frames) do
     Enum.reduce(frames, conn, fn
       window_update(stream_id: 0), conn ->
-        put_in(conn.receive_window, conn.receive_window_size)
+        put_in(conn.receive_window_remaining, conn.receive_window_size)
 
       window_update(stream_id: stream_id), conn ->
         put_in(
-          conn.streams[stream_id].receive_window,
+          conn.streams[stream_id].receive_window_remaining,
           conn.streams[stream_id].receive_window_size
         )
     end)
@@ -2199,7 +2225,7 @@ defmodule Mint.HTTP2 do
       state: :reserved_remote,
       send_window_size: conn.server_settings.initial_window_size,
       receive_window_size: conn.client_settings.initial_window_size,
-      receive_window: conn.client_settings.initial_window_size,
+      receive_window_remaining: conn.client_settings.initial_window_size,
       received_first_headers?: false
     }
 

test/mint/http2/conn_test.exs

@@ -131,7 +131,6 @@ defmodule Mint.HTTP2Test do
       assert_http2_error error, {:protocol_error, "received invalid frame ping during handshake"}
       refute HTTP2.open?(conn)
     end
-
   end
 
   describe "set_window_size/3" do
@@ -141,12 +140,12 @@ defmodule Mint.HTTP2Test do
          %{conn: conn} do
       assert HTTP2.get_window_size(conn, :connection) == 65_535
       assert conn.receive_window_size == 65_535
-      assert conn.receive_window == 65_535
+      assert conn.receive_window_remaining == 65_535
 
       assert {:ok, conn} = HTTP2.set_window_size(conn, :connection, 1_000_000)
 
       assert conn.receive_window_size == 1_000_000
-      assert conn.receive_window == 1_000_000
+      assert conn.receive_window_remaining == 1_000_000
 
       assert_recv_frames [
         window_update(stream_id: 0, window_size_increment: 934_465)
@@ -159,12 +158,12 @@ defmodule Mint.HTTP2Test do
       assert_recv_frames [headers(stream_id: stream_id)]
 
       current = conn.streams[stream_id].receive_window_size
-      assert conn.streams[stream_id].receive_window == current
+      assert conn.streams[stream_id].receive_window_remaining == current
 
       assert {:ok, conn} = HTTP2.set_window_size(conn, {:request, ref}, current + 10_000)
 
       assert conn.streams[stream_id].receive_window_size == current + 10_000
-      assert conn.streams[stream_id].receive_window == current + 10_000
+      assert conn.streams[stream_id].receive_window_remaining == current + 10_000
 
       assert_recv_frames [
         window_update(stream_id: ^stream_id, window_size_increment: 10_000)
@@ -1878,7 +1877,7 @@ defmodule Mint.HTTP2Test do
       # a WINDOW_UPDATE for `16 MB - 65_535` so the server sees the peak
       # from the start.
       assert conn.receive_window_size == 16 * 1024 * 1024
-      assert conn.receive_window == 16 * 1024 * 1024
+      assert conn.receive_window_remaining == 16 * 1024 * 1024
     end
 
     test "advertises the configured stream window via SETTINGS", %{conn: conn} do
@@ -1889,13 +1888,41 @@ defmodule Mint.HTTP2Test do
       assert_recv_frames [headers(stream_id: stream_id)]
 
       assert conn.streams[stream_id].receive_window_size == 4 * 1024 * 1024
-      assert conn.streams[stream_id].receive_window == 4 * 1024 * 1024
+      assert conn.streams[stream_id].receive_window_remaining == 4 * 1024 * 1024
     end
 
     @tag connect_options: [connection_window_size: 1_000_000]
     test "supports a custom :connection_window_size", %{conn: conn} do
       assert conn.receive_window_size == 1_000_000
-      assert conn.receive_window == 1_000_000
+      assert conn.receive_window_remaining == 1_000_000
+    end
+
+    @tag :no_connection
+    test "streams opened before the SETTINGS ACK track the advertised window, not the default",
+         %{server_port: port, server_socket_task: server_socket_task} do
+      # Regression: when the user advertises a stream window smaller than
+      # the library default (4 MB), streams opened before the server's
+      # SETTINGS ACK must track the advertised value. Otherwise the
+      # client holds onto credit the server never granted, never crosses
+      # the refill threshold, never sends a stream-level WINDOW_UPDATE,
+      # and the connection stalls after the server exhausts its send
+      # window.
+      assert {:ok, conn} =
+               HTTP2.connect(:https, "localhost", port,
+                 transport_opts: [verify: :verify_none],
+                 client_settings: [initial_window_size: 65_535]
+               )
+
+      {:ok, _server_socket} = Task.await(server_socket_task)
+
+      # Open a request *before* the server has ACKed our SETTINGS — this
+      # is the pre-ACK window where the struct must already reflect what
+      # was advertised, not the library default.
+      assert {:ok, conn, ref} = HTTP2.request(conn, "GET", "/", [], nil)
+
+      stream_id = conn.ref_to_stream_id[ref]
+      assert conn.streams[stream_id].receive_window_size == 65_535
+      assert conn.streams[stream_id].receive_window_remaining == 65_535
     end
 
     @tag connect_options: [connection_window_size: 65_535]
@@ -1904,7 +1931,7 @@ defmodule Mint.HTTP2Test do
       # At 65_535 there's nothing to advertise beyond SETTINGS — the
       # preface should not carry an extra WINDOW_UPDATE.
       assert conn.receive_window_size == 65_535
-      assert conn.receive_window == 65_535
+      assert conn.receive_window_remaining == 65_535
     end
 
     test "rejects a :connection_window_size below the spec minimum" do