raptor 0.21.0 → 0.22.0

data/lib/raptor/http1.rb

@@ -8,6 +8,7 @@ require "tempfile"
 require "atomic-ruby/atomic_boolean"
 require "rack"
 
+require_relative "detached_body"
 require_relative "http"
 require_relative "raptor_http"
 require_relative "thread_locals"
@@ -97,6 +98,28 @@ module Raptor
       false
     end
 
+    # Encodes one HTTP/1.1 response chunk.
+    #
+    # @rbs (String chunk) -> String
+    def self.encode_chunk(chunk)
+      HttpParser.chunked_encode(String.new, chunk)
+    end
+
+    # Encodes the final HTTP/1.1 response chunk and its trailers.
+    #
+    # @rbs (Hash[String, String | Array[String]] trailers) -> String
+    def self.encode_trailers(trailers)
+      normalized = trailers.each_with_object({}) do |(key, value), headers|
+        name = key.match?(/[A-Z]/) ? key.downcase : key
+        next if name.start_with?(RACK_HEADER_PREFIX) || name == "status"
+
+        headers[name] = value
+      end
+      response = +"0\r\n"
+      HttpParser.format_headers(response, normalized)
+      response << "\r\n"
+    end
+
     # Advances an HTTP/1.x request parse from the state hash's buffered
     # bytes. A complete well-formed request returns with `:complete` set
     # plus populated `:env` and `:body`; malformed or oversized input flips
@@ -492,7 +515,7 @@ module Raptor
     #
     # @rbs (TCPSocket socket, Integer id, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Reactor reactor, AtomicThreadPool thread_pool, Integer request_count, String remote_addr, String url_scheme) -> void
     def process_client(socket, id, env, parse_data, body, reactor, thread_pool, request_count, remote_addr, url_scheme)
-      keep_alive = process_request(socket, env, parse_data, body, request_count, remote_addr, url_scheme)
+      keep_alive = process_request(socket, id, env, parse_data, body, reactor, request_count, remote_addr, url_scheme)
       eager_keepalive(socket, id, reactor, thread_pool, request_count, remote_addr, url_scheme) if keep_alive
     end
 
@@ -501,20 +524,22 @@ module Raptor
     # for another request.
     #
     # @param socket [TCPSocket] the client socket
+    # @param id [Integer] unique client identifier
     # @param env [Hash] partial env hash from the HTTP parser
     # @param parse_data [Hash] metadata from the parsing pass
     # @param body [String, nil] decoded request body
+    # @param reactor [Reactor] the reactor managing the client connection
     # @param request_count [Integer] number of requests handled on this connection
     # @param remote_addr [String] client IP address
     # @param url_scheme [String] "http" or "https"
     # @return [Boolean] true if the connection should be kept alive
     #
-    # @rbs (TCPSocket socket, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Integer request_count, String remote_addr, String url_scheme) -> bool
-    def process_request(socket, env, parse_data, body, request_count, remote_addr, url_scheme)
+    # @rbs (TCPSocket socket, Integer id, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Reactor reactor, Integer request_count, String remote_addr, String url_scheme) -> bool
+    def process_request(socket, id, env, parse_data, body, reactor, request_count, remote_addr, url_scheme)
       if @clean_fiber_locals
-        Fiber.new { perform_request(socket, env, parse_data, body, request_count, remote_addr, url_scheme) }.resume
+        Fiber.new { perform_request(socket, id, env, parse_data, body, reactor, request_count, remote_addr, url_scheme) }.resume
       else
-        perform_request(socket, env, parse_data, body, request_count, remote_addr, url_scheme)
+        perform_request(socket, id, env, parse_data, body, reactor, request_count, remote_addr, url_scheme)
       end
     ensure
       ThreadLocals.clear if @clean_thread_locals
@@ -522,13 +547,14 @@ module Raptor
 
     # Calls the Rack app and writes its response for one request.
     #
-    # @rbs (TCPSocket socket, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Integer request_count, String remote_addr, String url_scheme) -> bool
-    def perform_request(socket, env, parse_data, body, request_count, remote_addr, url_scheme)
+    # @rbs (TCPSocket socket, Integer id, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Reactor reactor, Integer request_count, String remote_addr, String url_scheme) -> bool
+    def perform_request(socket, id, env, parse_data, body, reactor, request_count, remote_addr, url_scheme)
       rack_env = nil
       status = nil
       headers = nil
       hijacked = false
       keep_alive = false
+      detached = false
       response_started = false
 
       begin
@@ -540,16 +566,40 @@ module Raptor
           body.close if body.respond_to?(:close)
         else
           hijacked = headers.is_a?(Hash) && !!headers[Rack::RACK_HIJACK]
-          streaming = body.respond_to?(:call) && !body.respond_to?(:each)
-          keep_alive = (hijacked || streaming) ? false : keep_alive?(rack_env, request_count)
-          response_size = response_size(headers, body) if @access_log_io && !hijacked
-          response_started = true
-          write_response(socket, rack_env, status, headers, body, keep_alive: keep_alive)
+          no_body = rack_env[Rack::REQUEST_METHOD] == "HEAD" || (status >= 100 && status < 200) || status == 204 || status == 304
+          detached = body.is_a?(DetachedBody) && !no_body
+          if detached
+            chunked = rack_env[Rack::SERVER_PROTOCOL] == HTTP_11
+            keep_alive = chunked && keep_alive?(rack_env, request_count)
+            response_started = true
+            write_detached_response(socket, status, headers, chunked: chunked, keep_alive: keep_alive)
+            finished = proc do |reason|
+              error = IOError.new("detached response closed") unless reason == :closed
+              write_access_log(rack_env, status, "-", remote_addr) if @access_log_io
+              Http.call_response_finished(rack_env, status, headers, error)
+            end
+            reactor.attach_http1_body(
+              socket,
+              id,
+              body,
+              {chunked: chunked, keep_alive: keep_alive, request_count: request_count, remote_addr: remote_addr, url_scheme: url_scheme},
+              finished
+            )
+          else
+            streaming = body.respond_to?(:call) && !body.respond_to?(:each)
+            keep_alive = (hijacked || streaming) ? false : keep_alive?(rack_env, request_count)
+            response_size = response_size(headers, body) if @access_log_io && !hijacked
+            response_started = true
+            write_response(socket, rack_env, status, headers, body, keep_alive: keep_alive)
+            body.finish(:closed) if body.is_a?(DetachedBody)
+          end
         end
 
-        write_access_log(rack_env, status, response_size, remote_addr) if @access_log_io && !hijacked
-        Http.call_response_finished(rack_env, status, headers, nil)
-        keep_alive && !hijacked
+        unless detached
+          write_access_log(rack_env, status, response_size, remote_addr) if @access_log_io && !hijacked
+          Http.call_response_finished(rack_env, status, headers, nil)
+        end
+        keep_alive && !hijacked && !detached
       rescue => error
         keep_alive = false
         handle_app_error(socket, rack_env, status, headers, error, response_started: response_started, hijacked: hijacked)
@@ -557,7 +607,7 @@ module Raptor
         rack_input = rack_env && rack_env[Rack::RACK_INPUT]
         rack_input.close! rescue nil if rack_input.respond_to?(:close!)
 
-        unless hijacked || keep_alive
+        unless hijacked || keep_alive || detached
           socket.close rescue nil
         end
       end
@@ -666,9 +716,11 @@ module Raptor
 
         keep_alive = process_request(
           socket,
+          id,
           env,
           parse_data,
           body,
+          reactor,
           request_count,
           remote_addr,
           url_scheme
@@ -895,6 +947,24 @@ module Raptor
       socket_write(socket, response)
     end
 
+    # Starts a detached response, chunked on HTTP/1.1 and ended by closing
+    # the connection on HTTP/1.0.
+    #
+    # @rbs (TCPSocket socket, Integer status, Hash[String, String | Array[String]] headers, chunked: bool, keep_alive: bool) -> void
+    def write_detached_response(socket, status, headers, chunked:, keep_alive:)
+      validate_status(status)
+      headers = normalize_headers(headers)
+      validate_headers(headers, status, false)
+      headers.delete(Rack::CONTENT_LENGTH)
+      headers[Rack::TRANSFER_ENCODING] = TRANSFER_ENCODING_CHUNKED if chunked
+      headers["connection"] = keep_alive ? CONNECTION_KEEPALIVE : CONNECTION_CLOSE
+
+      response = build_status_line(chunked ? HTTP_11 : HTTP_10, status)
+      HttpParser.format_headers(response, headers)
+      response << "\r\n"
+      socket_write(socket, response)
+    end
+
     # Writes a complete HTTP response to the socket.
     #
     # @param socket [TCPSocket] the client socket to write to

data/lib/raptor/http2.rb

@@ -8,6 +8,7 @@ require "atomic-ruby/atomic_boolean"
 require "atomic-ruby/atomic_condition_variable"
 require "rack"
 
+require_relative "detached_body"
 require_relative "http"
 require_relative "raptor_http2"
 require_relative "thread_locals"
@@ -18,13 +19,12 @@ module Raptor
   class Http2
     RESPONSE_TRAILERS = "raptor.response_trailers"
 
-    # Serialises concurrent frame writes on a single HTTP/2 connection so
-    # exactly one thread is writing at any moment.
+    # Queues concurrent frame writes while the reactor remains the sole
+    # owner of the connection socket.
     #
     class Writer
-      IDLE = :idle
-
-      # @rbs @state: Atom
+      # @rbs @reactor: Reactor?
+      # @rbs @connection_id: Integer?
       # @rbs @write_timeout: Integer
 
       # Creates a new Writer.
@@ -34,45 +34,46 @@ module Raptor
       #
       # @rbs (write_timeout: Integer) -> void
       def initialize(write_timeout:)
-        @state = Atom.new(IDLE)
+        @reactor = nil
+        @connection_id = nil
         @write_timeout = write_timeout
       end
 
-      # Writes frames to the socket, coordinating with concurrent writers
-      # so that exactly one thread is actively writing at any time.
+      # Routes subsequent frame writes through the connection's reactor.
+      #
+      # @param reactor [Reactor] the reactor that owns the connection
+      # @param connection_id [Integer] unique connection identifier
+      # @return [void]
+      #
+      # @rbs (Reactor reactor, Integer connection_id) -> void
+      def attach(reactor, connection_id)
+        @reactor = reactor
+        @connection_id = connection_id
+      end
+
+      # Queues frames for the reactor to write. Before attachment, writes
+      # directly so the writer remains usable during connection setup.
       #
       # @param socket [OpenSSL::SSL::SSLSocket] the connection socket
-      # @param frames [Array<String>] frame bytes to write in order
+      # @param frames [Array<String>, nil] frame bytes to write in order
       # @return [void]
       #
-      # @rbs (OpenSSL::SSL::SSLSocket socket, Array[String] frames) -> void
+      # @rbs (OpenSSL::SSL::SSLSocket socket, Array[String]? frames) -> void
       def write_frames(socket, frames)
         return if !frames || frames.empty?
 
-        claimed = false
-        @state.swap do |current|
-          if current.equal?(IDLE)
-            claimed = true
-            frames
-          else
-            claimed = false
-            current + frames
-          end
+        if @reactor
+          @reactor.write_http2_frames(@connection_id, frames)
+        else
+          Http.socket_write(socket, frames.join, timeout: @write_timeout) rescue nil
         end
+      end
 
-        return unless claimed
-
-        loop do
-          pending = nil
-          @state.swap do |current|
-            pending = current
-            current.empty? ? IDLE : []
-          end
-
-          break if pending.empty?
-
-          Http.socket_write(socket, pending.join, timeout: @write_timeout) rescue nil
-        end
+      # Attaches a response body that outlives its application thread.
+      #
+      # @rbs (Integer stream_id, DetachedBody body, ^(Symbol) -> void finished) -> bool
+      def attach_body(stream_id, body, finished)
+        @reactor.attach_http2_body(@connection_id, stream_id, body, finished)
       end
     end
 
@@ -133,6 +134,30 @@ module Raptor
         end
       end
 
+      # Reserves outbound capacity without waiting for a window update.
+      #
+      # @param stream_id [Integer] the HTTP/2 stream identifier
+      # @param max_bytes [Integer] the largest size the caller would like to send
+      # @return [Integer] available bytes, or 0 when flow control is exhausted
+      #
+      # @rbs (Integer stream_id, Integer max_bytes) -> Integer
+      def try_acquire(stream_id, max_bytes)
+        check(stream_id)
+        initial = @initial_stream_window.value
+        stream_window = @stream_windows.value[stream_id] || initial
+        capped = [max_bytes, MAX_FRAME_SIZE, stream_window].min
+        return 0 unless capped.positive?
+
+        granted = reserve_connection(capped)
+        if granted.positive?
+          @stream_windows.swap do |windows|
+            current = windows[stream_id] || initial
+            windows.merge(stream_id => current - granted)
+          end
+        end
+        granted
+      end
+
       # Increments the connection-level send window by `increment` bytes.
       #
       # @param increment [Integer] the byte count to add
@@ -900,10 +925,14 @@ module Raptor
       rounds = 0
       loop do
         reactor.acknowledge_http2_ping(result[:id], result[:ping_acknowledgements])
-        result[:cancelled_streams]&.each { |stream_id| flow_control.cancel_stream(stream_id) }
+        result[:cancelled_streams]&.each do |stream_id|
+          flow_control.cancel_stream(stream_id)
+          reactor.cancel_http2_body(result[:id], stream_id)
+        end
 
-        if flow_control && (result[:window_updates] || result[:peer_initial_window_size])
+        if flow_control && (result[:window_updates]&.any? || result[:peer_initial_window_size])
           apply_flow_control_updates(flow_control, result)
+          reactor.resume_http2_bodies(result[:id])
         end
 
         writer.write_frames(socket, result[:outgoing_frames])
@@ -1025,11 +1054,26 @@ module Raptor
       status = nil
       response_headers = nil
       response_started = false
+      detached = false
 
       flow_control.check(stream_id)
       env = build_rack_env(headers, body, socket, writer, flow_control, stream_id, remote_addr: remote_addr)
       status, response_headers, response_body = @app.call(env)
 
+      no_body = env[Rack::REQUEST_METHOD] == "HEAD" || (status >= 100 && status < 200) || status == 204 || status == 304
+      if response_body.is_a?(DetachedBody) && !no_body
+        finished = proc do |reason|
+          error = StreamClosedError.new unless reason == :closed
+          write_access_log(env, status, "-", remote_addr) if @access_log_io
+          Http.call_response_finished(env, status, response_headers, error)
+          flow_control.discard_stream(stream_id)
+        end
+        detached = write_http2_detached_response(socket, writer, flow_control, stream_id, status, response_headers, response_body, finished) do
+          response_started = true
+        end
+        return
+      end
+
       response_size = write_http2_response(
         socket,
         writer,
@@ -1041,7 +1085,11 @@ module Raptor
         trailers: env[RESPONSE_TRAILERS],
         request_method: env[Rack::REQUEST_METHOD]
       ) { response_started = true }
-      response_body.close if response_body.respond_to?(:close)
+      if response_body.is_a?(DetachedBody)
+        response_body.finish(:closed)
+      elsif response_body.respond_to?(:close)
+        response_body.close
+      end
       write_access_log(env, status, response_size, remote_addr) if @access_log_io
       Http.call_response_finished(env, status, response_headers, nil)
     rescue StreamClosedError => error
@@ -1060,7 +1108,21 @@ module Raptor
         raise
       end
     ensure
-      flow_control.discard_stream(stream_id) if flow_control
+      flow_control.discard_stream(stream_id) if flow_control && !detached
+    end
+
+    # Starts a detached HTTP/2 response after writing its response headers.
+    #
+    # @rbs (OpenSSL::SSL::SSLSocket socket, Writer writer, FlowControl flow_control, Integer stream_id, Integer status, Hash[String, String | Array[String]] headers, DetachedBody body, ^(Symbol) -> void finished) { () -> void } -> bool
+    def write_http2_detached_response(socket, writer, flow_control, stream_id, status, headers, body, finished)
+      flow_control.check(stream_id)
+      parser = Http2Parser.new
+      encoded = parser.encode_response_headers(status, headers)
+      writer.write_frames(socket, [parser.build_frame(:headers, FLAG_END_HEADERS, stream_id, encoded)])
+      yield
+      attached = writer.attach_body(stream_id, body, finished)
+      write_http2_reset_stream(socket, writer, stream_id, ERROR_REFUSED_STREAM) unless attached
+      true
     end
 
     # Writes a Rack response as HTTP/2 frames to the socket, partitioning