yamine 0.23.0 → 0.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 308817ac04ecc72d2d0af8ca1a9262d502d5dfb27d4b21a11403c12eebac4aa0
-  data.tar.gz: 0d8c7fdc05ef6bb45ca01165901f14d9d9d17b80e4e86d1c32614fb8f12594a0
+  metadata.gz: c868efafc13a1f8bf3aadad4cf4d0cacffe110e51e091e30b79eb1e81d2f4a24
+  data.tar.gz: f888229b7d618e2936108a27342f9227c8f986e46611ba22ea880052ca190a49
 SHA512:
-  metadata.gz: ffc43e16572dee62e053441f56aa2472fbf3c388b80fdbbae17a79fbae0a4e6fae03819dd72d0830239aaaabfa8d04b1952433083cb9339fb7776b2b2bdbbf5e
-  data.tar.gz: d51b33e1780b9cd49cc87655bdb51adfc007736c29b67ac580fda2c2126c7cf80471e24fc4446f805f9230435af6e682132eaed599de5d7222e2125cb3c1294b
+  metadata.gz: 3ad556cdad8d143e9beb87ba0cdcfc2fa5a686ad04d10ad763e048f4ace90d084527ecc23064998ac37d9a65705e831b3216675ab5306a5da8b869680f302371
+  data.tar.gz: b1b11d113410b72139b9f8ea19592342b29b40edab39869861e2488f4c4c8f193de00ad564f2ba771dba5e2a33072abd41c5e0f10c649dd0ff55bceaaeab98ff

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.23.1] - 2026-10-02
+
+### Fixed
+
+- **A chunked response now ends at its terminator instead of at end of
+  file.** The relay had one way to end a body with no Content-Length —
+  copy until the backend hung up — and it read every such body as
+  close-delimited. But a chunked body ends at its terminating chunk, and
+  the backend holding the connection open past it is keep-alive doing
+  exactly what it promised. So the relay blocked for the whole idle
+  bound, sixty seconds by default, with the client's connection pinned
+  the entire time. Every streamed page, every ActionController::Live
+  response and every event stream is framed this way, and the request
+  that followed on that connection — typically the page's main
+  JavaScript chunk — got nothing back until the connection was reaped.
+  A load test could not see it, because every request in one opened its
+  own connection. Chunked framing is now read rather than assumed, bytes
+  still cross to the client exactly as the backend wrote them, and the
+  connection is free for the next request the moment the terminator
+  arrives.
+- `minitest/mock` is required by the test helper, so `Object#stub` is
+  available to every test rather than only the ones that load it.
+
 ## [0.23.0] - 2026-10-02
 
 ### Fixed

data/lib/yamine/proxy.rb

@@ -64,6 +64,7 @@ module Yamine
     # which is also the only one a retry can be safe for.
     HeadTimeout = Class.new(IdleTimeout)
     CHUNK_BYTES = 16_384
+    CRLF = "\r\n"
     # Route cache: routes.json is the source of truth, but re-reading
     # and re-parsing it on every request is wasteful under HMR polling.
     # Keyed on file mtime, so a freshly registered route is visible on
@@ -449,16 +450,26 @@ module Yamine
     def relay_after_head(sock, backend, rhead, rbuf, rheaders, headers, target)
       begin
         write_all(sock, rhead)
-        write_all(sock, rbuf) unless rbuf.empty?
 
         rlen = content_length(rheaders)
-        if rlen.nil?
-          # No Content-Length: close-delimited response.
-          copy_stream(backend, sock)
-          return [:close, nil]
+        if chunked?(rheaders)
+          # The chunk relay reads the framing to find where the body ends,
+          # so it takes the read-ahead itself — handing it bytes already on
+          # the wire would send the body twice.
+          relay_chunked(backend, sock, rbuf)
+        else
+          write_all(sock, rbuf) unless rbuf.empty?
+
+          if rlen.nil?
+            # No Content-Length and no chunk framing: the body really does
+            # end at end of file, because the backend is closing to say so.
+            copy_stream(backend, sock)
+            return [:close, nil]
+          else
+            remaining = rlen - rbuf.bytesize
+            copy_stream(backend, sock, remaining) if remaining > 0
+          end
         end
-        remaining = rlen - rbuf.bytesize
-        copy_stream(backend, sock, remaining) if remaining > 0
       rescue EOFError
         @on_error.call("backend for #{headers["host"]}#{target} closed mid-body, " \
                        "before its Content-Length of #{rheaders["content-length"]} was met")
@@ -486,8 +497,13 @@ module Yamine
       return if rhead.nil?
 
       write_all(sock, rhead)
-      write_all(sock, rbuf) unless rbuf.empty?
-      copy_stream(backend, sock)
+      _rm, _rt, rheaders = parse_head(rhead)
+      if chunked?(rheaders)
+        relay_chunked(backend, sock, rbuf)
+      else
+        write_all(sock, rbuf) unless rbuf.empty?
+        copy_stream(backend, sock)
+      end
     rescue IOError, SystemCallError
       nil
     end
@@ -652,6 +668,79 @@ module Yamine
       end
     end
 
+    # Chunked framing is the one body the proxy has to read rather than
+    # copy, because it is the only thing that says where the body ends. It
+    # ends at the terminating chunk — not at end of file, and the backend
+    # holding the connection open past it is keep-alive doing exactly what
+    # it promised. Every streamed page, every ActionController::Live
+    # response and every event stream is framed this way.
+    #
+    # Bytes cross to the client exactly as the backend wrote them; only the
+    # framing is read, never rewritten. `buf` is the read-ahead already
+    # past the response head.
+    def relay_chunked(src, dst, buf)
+      loop do
+        line = take_line(src, buf)
+        return if line.nil?
+
+        write_all(dst, line)
+        size = chunk_size(line)
+        if size.zero?
+          relay_trailers(src, dst, buf)
+          return
+        end
+
+        write_all(dst, take_bytes(src, buf, size) || +"")
+        write_all(dst, take_line(src, buf) || +"")
+      end
+    end
+
+    # Trailers run to the blank line that closes them.
+    def relay_trailers(src, dst, buf)
+      loop do
+        line = take_line(src, buf)
+        return if line.nil?
+
+        write_all(dst, line)
+        return if line == CRLF
+      end
+    end
+
+    # A chunk-size line, less the CRLF that ends it. Extensions after a
+    # semicolon are the sender's and are not ours to weigh.
+    def chunk_size(line)
+      line.split(";", 2).first.to_s.strip.to_i(16)
+    end
+
+    def take_line(sock, buf)
+      until (index = buf.index(CRLF))
+        return nil unless fill_buf(sock, buf)
+      end
+      buf.slice!(0, index + 2)
+    end
+
+    def take_bytes(sock, buf, count)
+      out = +""
+      while out.bytesize < count
+        return nil if buf.empty? && !fill_buf(sock, buf)
+
+        take = [count - out.bytesize, buf.bytesize].min
+        out << buf.slice!(0, take)
+      end
+      out
+    end
+
+    def fill_buf(sock, buf)
+      buf << read_chunk(sock, CHUNK_BYTES)
+      true
+    rescue EOFError
+      false
+    end
+
+    def chunked?(headers)
+      headers["transfer-encoding"].to_s.downcase.include?("chunked")
+    end
+
     # Block until the socket is ready for the direction a nonblocking op
     # asked for; a timeout when the bound passes with no progress. A
     # caller-supplied bound only changes how long we wait — what a timeout

data/lib/yamine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yamine
-  VERSION = "0.23.0"
+  VERSION = "0.23.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yamine
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.23.1
 platform: ruby
 authors:
 - Kaka Ruto