quicsilver 0.3.0 → 0.4.0

data/lib/quicsilver/protocol/response_parser.rb

@@ -1,39 +1,28 @@
 # frozen_string_literal: true
 
-require "stringio"
-require_relative "qpack/header_block_decoder"
+require_relative "frame_parser"
 
 module Quicsilver
   module Protocol
-    class ResponseParser
-      attr_reader :headers, :status
-
-      def frames
-        @frames || []
-      end
-
-      DEFAULT_DECODER = Qpack::HeaderBlockDecoder.default
+    class ResponseParser < FrameParser
+      attr_reader :status
 
       def initialize(data, **opts)
+        decoder = opts.delete(:decoder) || DEFAULT_DECODER
+        super(decoder: decoder, max_body_size: opts[:max_body_size],
+              max_header_size: opts[:max_header_size])
         @data = data
-        if opts.empty?
-          @decoder = DEFAULT_DECODER
-          @use_parse_cache = true
-        else
-          @decoder = opts[:decoder] || DEFAULT_DECODER
-          @max_body_size = opts[:max_body_size]
-          @max_header_size = opts[:max_header_size]
-          @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size
-        end
+        @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size
       end
 
       # Reset parser with new data for object reuse (avoids allocation overhead)
       def reset(data)
         @data = data
         @status = nil
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
-        @body_io = nil
+        @body = nil
         @cached_body_str = nil
       end
 
@@ -55,35 +44,22 @@ module Quicsilver
             @headers = cached[1]
             @frames = cached[2]
             @cached_body_str = cached[3]
+            @trailers = cached[4] || {}
             @last_data = data
             return
           end
         end
         @status = nil
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
-        @body_io = nil
+        @body = nil
         @cached_body_str = nil
         parse!
         cache_result if @use_parse_cache
       end
 
-      def body
-        if @body_io
-          @body_io.rewind
-          @body_io
-        elsif @cached_body_str
-          @body_io = StringIO.new(@cached_body_str)
-          @body_io.set_encoding(Encoding::ASCII_8BIT)
-          @body_io
-        else
-          EMPTY_BODY
-        end
-      end
-
-      EMPTY_BODY = StringIO.new("".b).tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
-
-      # Class-level parse result cache: data → [status, headers, frames, body_str]
+      # Class-level parse result cache: data → [status, headers, frames, body_str, trailers]
       PARSE_CACHE = {}
       PARSE_CACHE_MAX = 128
       PARSE_OID_CACHE = {}
@@ -98,6 +74,7 @@ module Quicsilver
             @headers = cached[1]
             @frames = cached[2]
             @cached_body_str = cached[3]
+            @trailers = cached[4] || {}
             return
           end
         end
@@ -108,10 +85,10 @@ module Quicsilver
 
       private def cache_result
         if PARSE_CACHE.size < PARSE_CACHE_MAX && @data.bytesize <= 1024
-          body_str = if @body_io
-            @body_io.rewind
-            s = @body_io.read
-            @body_io.rewind
+          body_str = if @body
+            @body.rewind
+            s = @body.read
+            @body.rewind
             s
           end
           key = @data.frozen? ? @data : @data.dup.freeze
@@ -119,82 +96,14 @@ module Quicsilver
             @status,
             @headers.dup.freeze,
             (@frames || []).freeze,
-            body_str&.freeze
+            body_str&.freeze,
+            (@trailers.empty? ? nil : @trailers.dup.freeze)
           ].freeze
         end
       end
 
       private
 
-      # Frame types forbidden on request streams — O(1) lookup
-      CONTROL_ONLY_SET = Protocol::CONTROL_ONLY_FRAMES.each_with_object({}) { |f, h| h[f] = true }.freeze
-
-      def parse!
-        @headers = {}
-        @status = nil
-        @body_io = nil
-        @frames = nil
-        buffer = @data
-        offset = 0
-        headers_received = false
-        buf_size = buffer.bytesize
-
-        while offset < buf_size
-          break if buf_size - offset < 2
-
-          # Inline single-byte varint fast path (covers frame types 0x00-0x3F)
-          type_byte = buffer.getbyte(offset)
-          if type_byte < 0x40
-            type = type_byte
-            type_len = 1
-          else
-            type, type_len = Protocol.decode_varint_str(buffer, offset)
-          end
-
-          len_byte = buffer.getbyte(offset + type_len)
-          if len_byte < 0x40
-            length = len_byte
-            length_len = 1
-          else
-            length, length_len = Protocol.decode_varint_str(buffer, offset + type_len)
-            break if length_len == 0
-          end
-          break if type_len == 0
-
-          header_len = type_len + length_len
-
-          break if buf_size < offset + header_len + length
-
-          payload = buffer.byteslice(offset + header_len, length)
-          (@frames ||= []) << { type: type, length: length, payload: payload }
-
-          if CONTROL_ONLY_SET.key?(type)
-            raise Protocol::FrameError, "Frame type 0x#{type.to_s(16)} not allowed on request streams"
-          end
-
-          case type
-          when 0x01 # HEADERS
-            if @max_header_size && length > @max_header_size
-              raise Protocol::MessageError, "Header block #{length} exceeds limit #{@max_header_size}"
-            end
-            parse_headers(payload)
-            headers_received = true
-          when 0x00 # DATA
-            raise Protocol::FrameError, "DATA frame before HEADERS" unless headers_received
-            unless @body_io
-              @body_io = StringIO.new
-              @body_io.set_encoding(Encoding::ASCII_8BIT)
-            end
-            @body_io.write(payload)
-            if @max_body_size && @body_io.size > @max_body_size
-              raise Protocol::MessageError, "Body size #{@body_io.size} exceeds limit #{@max_body_size}"
-            end
-          end
-
-          offset += header_len + length
-        end
-      end
-
       # Cache for validated response header results
       HEADERS_CACHE = {}
       HEADERS_CACHE_MAX = 256
@@ -227,23 +136,6 @@ module Quicsilver
           HEADERS_CACHE[key] = { status: @status, headers: @headers.dup.freeze }.freeze
         end
       end
-
-      # RFC 9110 §5.3: Combine duplicate header values.
-      # - set-cookie: join with "\n" (Rack convention, MUST NOT combine with comma)
-      # - cookie: join with "; " (RFC 9114 §4.2.1)
-      # - all others: join with ", "
-      def store_header(name, value)
-        if @headers.key?(name)
-          separator = case name
-            when "set-cookie" then "\n"
-            when "cookie" then "; "
-            else ", "
-          end
-          @headers[name] = "#{@headers[name]}#{separator}#{value}"
-        else
-          @headers[name] = value
-        end
-      end
     end
   end
 end

data/lib/quicsilver/protocol/stream_input.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "protocol/http/body/writable"
+
+module Quicsilver
+  module Protocol
+    # A streaming request body backed by Protocol::HTTP::Body::Writable.
+    #
+    # QUIC RECEIVE events push chunks via {write}, while the application
+    # reads them via {read}. This enables concurrent streaming — the app
+    # can start processing before the full body arrives.
+    #
+    # Follows the protocol-http Body::Writable contract:
+    # - write(chunk) — called by the QUIC transport on RECEIVE events
+    # - close_write  — called on RECEIVE_FIN to signal end of body
+    # - read         — called by the application (blocks until data available)
+    # - close        — called to abort (e.g., stream reset)
+    #
+    # Optional features:
+    # - Back-pressure via Thread::SizedQueue (bounded buffer)
+    # - Read timeout for slow client protection
+    #
+    class StreamInput < ::Protocol::HTTP::Body::Writable
+      class ReadTimeout < StandardError; end
+
+      # @param length [Integer, nil] The content-length if known from headers.
+      # @param queue_size [Integer, nil] Maximum buffered chunks for back-pressure.
+      #   nil (default) = unbounded. When bounded, write blocks if queue is full,
+      #   which naturally maps to QUIC flow control.
+      # @param read_timeout [Numeric, nil] Seconds to wait for data before raising
+      #   ReadTimeout. nil (default) = wait forever.
+      def initialize(length = nil, queue_size: nil, read_timeout: nil)
+        queue = if queue_size
+          Thread::SizedQueue.new(queue_size)
+        else
+          Thread::Queue.new
+        end
+
+        super(length, queue: queue)
+        @read_timeout = read_timeout
+        @bytes_written = 0
+      end
+
+      # @attribute [Numeric, nil] Read timeout in seconds.
+      attr_reader :read_timeout
+
+      # Track bytes written for content-length validation.
+      def write(chunk)
+        @bytes_written += chunk.bytesize
+        super
+      end
+
+      # Signal that no more data will be written.
+      # Validates content-length if declared (RFC 9114 §4.1.2) — raises
+      # MessageError if total bytes written don't match.
+      def close_write(error = nil)
+        if @length && @bytes_written != @length
+          raise Protocol::MessageError, "Content-length mismatch: header=#{@length}, body=#{@bytes_written}"
+        end
+        super
+      end
+
+      # Read the next available chunk, with optional timeout.
+      #
+      # @returns [String | Nil] The next chunk, or nil if the body is finished.
+      # @raises [ReadTimeout] If no data arrives within the timeout.
+      # @raises [Exception] If the body was closed due to an error.
+      def read
+        if @read_timeout
+          read_with_timeout
+        else
+          super
+        end
+      end
+
+      private
+
+      def read_with_timeout
+        raise @error if @error
+
+        # Thread::Queue#pop(timeout:) blocks efficiently (no busy-wait).
+        # Returns nil on timeout OR on closed empty queue — disambiguate below.
+        chunk = @queue.pop(timeout: @read_timeout)
+
+        raise @error if @error
+
+        # nil means either timeout or body finished (queue closed + empty).
+        # If queue is closed, the body is done — return nil (EOF).
+        # If queue is still open, we timed out waiting for data.
+        if chunk.nil? && !@queue.closed?
+          raise ReadTimeout, "No data received within #{@read_timeout}s"
+        end
+
+        chunk
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/stream_output.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+
+module Quicsilver
+  module Protocol
+    # Reads from a Protocol::HTTP::Body::Readable response body and writes
+    # HTTP/3 DATA frames to the transport.
+    #
+    # Transport-agnostic: takes a writer block/callable that handles the actual
+    # sending. Works with msquic, kernel QUIC sockets, or any transport that
+    # can send bytes with a FIN flag.
+    #
+    class StreamOutput
+      # @param body [Protocol::HTTP::Body::Readable] The response body to stream.
+      # @param writer [#call] A callable that accepts (data, fin) — sends bytes
+      #   to the transport. `fin: true` signals end of stream.
+      def initialize(body, &writer)
+        @body = body
+        @writer = writer
+      end
+
+      # Stream all chunks from the response body as HTTP/3 DATA frames.
+      #
+      # Each chunk is wrapped in an HTTP/3 DATA frame (type 0x00) and sent
+      # via the writer. The final chunk is sent with fin=true.
+      #
+      # @param send_fin [Boolean] Whether to send FIN after the last chunk.
+      #   Set to false when trailers will follow.
+      # @return [void]
+      def stream(send_fin: true)
+        last_chunk = nil
+
+        while (chunk = @body.read)
+          if last_chunk
+            @writer.call(build_data_frame(last_chunk), false)
+          end
+          last_chunk = chunk
+        end
+
+        if last_chunk
+          @writer.call(build_data_frame(last_chunk), send_fin)
+        elsif send_fin
+          @writer.call("".b, true)
+        end
+      ensure
+        @body.close if @body.respond_to?(:close)
+      end
+
+      private
+
+      def build_data_frame(payload)
+        payload = payload.b
+        Quicsilver::Protocol.encode_varint(Quicsilver::Protocol::FRAME_DATA) +
+          Quicsilver::Protocol.encode_varint(payload.bytesize) +
+          payload
+      end
+    end
+  end
+end

data/lib/quicsilver/server/request_handler.rb

@@ -3,68 +3,31 @@
 module Quicsilver
   class Server
     class RequestHandler
-      # Safe HTTP methods allowed in 0-RTT early data (RFC 9110 §9.2.1)
       SAFE_METHODS = %w[GET HEAD OPTIONS].freeze
 
+      attr_reader :adapter
+
       def initialize(app:, configuration:, request_registry:, cancelled_streams:, cancelled_mutex:)
-        @app = app
         @configuration = configuration
         @request_registry = request_registry
         @cancelled_streams = cancelled_streams
         @cancelled_mutex = cancelled_mutex
+        @adapter = Protocol::Adapter.new(app)
       end
 
       def call(connection, stream, early_data: false)
-        parser = Protocol::RequestParser.new(
-          stream.data,
-          max_body_size: @configuration.max_body_size,
-          max_header_size: @configuration.max_header_size,
-          max_header_count: @configuration.max_header_count,
-          max_frame_payload_size: @configuration.max_frame_payload_size
-        )
-        parser.parse
-        parser.validate_headers!  # raises MessageError for missing/invalid pseudo-headers
-        env = parser.to_rack_env
-
-        if env && @app
-          env["quicsilver.early_data"] = early_data
-
-          # RFC 8470: reject unsafe methods on 0-RTT unless app opted in
-          if @configuration.early_data_policy == :reject &&
-             early_data && !SAFE_METHODS.include?(env["REQUEST_METHOD"])
-            connection.send_error(stream, 425, "Too Early") if stream.writable?
-            return
-          end
-
-          @request_registry.track(
-            stream.stream_id,
-            connection.handle,
-            path: env["PATH_INFO"] || "/",
-            method: env["REQUEST_METHOD"] || "GET"
-          )
-
-          status, headers, body = @app.call(env)
-
-          if cancelled_stream?(stream.stream_id)
-            Quicsilver.logger.debug("Skipping response for cancelled stream #{stream.stream_id}")
-            return
-          end
+        request = parse_request(connection, stream, early_data: early_data)
+        return unless request
 
-          raise "Stream handle not found for stream #{stream.stream_id}" unless stream.writable?
+        response = @adapter.call(request)
 
-          connection.send_response(stream, status, headers, body, head_request: env["REQUEST_METHOD"] == "HEAD")
-          @request_registry.complete(stream.stream_id)
-        else
-          connection.send_error(stream, 400, "Bad Request") if stream.writable?
-        end
+        send_response(connection, stream, request, response)
       rescue Server::DrainTimeoutError
         Quicsilver.logger.debug("Request interrupted by drain: stream #{stream.stream_id}")
       rescue Protocol::FrameError => e
-        # Frame errors are connection-level: signal via CONNECTION_CLOSE with H3 error code
         Quicsilver.logger.error("Frame error: #{e.message} (0x#{e.error_code.to_s(16)})")
         Quicsilver.connection_shutdown(connection.handle, e.error_code, false) rescue nil
       rescue Protocol::MessageError => e
-        # Message errors are stream-level: signal via RESET_STREAM with H3 error code
         Quicsilver.logger.error("Message error: #{e.message} (0x#{e.error_code.to_s(16)})")
         Quicsilver.stream_reset(stream.stream_handle, e.error_code) if stream.writable?
       rescue => e
@@ -78,6 +41,95 @@ module Quicsilver
 
       private
 
+      def parse_request(connection, stream, early_data: false)
+        parser = Protocol::RequestParser.new(
+          stream.data,
+          max_body_size: @configuration.max_body_size,
+          max_header_size: @configuration.max_header_size,
+          max_header_count: @configuration.max_header_count,
+          max_frame_payload_size: @configuration.max_frame_payload_size
+        )
+        parser.parse
+        parser.validate_headers!
+
+        headers = parser.headers
+        unless headers && !headers.empty?
+          connection.send_error(stream, 400, "Bad Request") if stream.writable?
+          return
+        end
+
+        method = headers[":method"]
+
+        if @configuration.early_data_policy == :reject &&
+           early_data && !SAFE_METHODS.include?(method)
+          connection.send_error(stream, 425, "Too Early") if stream.writable?
+          return
+        end
+
+        request, body = @adapter.build_request(headers)
+        request.headers.add("quicsilver-early-data", early_data.to_s)
+
+        # Wire interim_response so apps can send 103 Early Hints.
+        # Falcon mode: app calls request.send_interim_response(103, headers)
+        # Rack mode: bridged to rack.early_hints via EarlyHintsMiddleware
+        request.interim_response = ->(status, headers) {
+          connection.send_informational(stream, status, headers)
+        }
+
+        if body && parser.body && parser.body.size > 0
+          parser.body.rewind
+          body_data = parser.body.read
+          body.write(body_data) unless body_data.empty?
+        end
+        body&.close_write
+
+        connection.apply_stream_priority(stream, parser.priority)
+
+        @request_registry.track(
+          stream.stream_id, connection.handle,
+          path: headers[":path"] || "/", method: method || "GET"
+        )
+
+        request
+      end
+
+      def send_response(connection, stream, request, response)
+        if cancelled_stream?(stream.stream_id)
+          Quicsilver.logger.debug("Skipping response for cancelled stream #{stream.stream_id}")
+          return
+        end
+
+        raise "Stream handle not found for stream #{stream.stream_id}" unless stream.writable?
+
+        headers = response.headers
+
+        # Extract trailers before flattening (Protocol::HTTP::Headers tracks
+        # trailer! state that a plain Hash would lose — needed for gRPC).
+        trailers = if headers.respond_to?(:trailer?) && headers.trailer?
+          trailer_hash = {}
+          headers.trailer.each { |name, value| trailer_hash[name] = value }
+          trailer_hash
+        end
+
+        response_headers = {}
+        if headers.respond_to?(:header)
+          headers.header.each { |name, value| response_headers[name] = value }
+        else
+          headers&.each { |name, value| response_headers[name] = value }
+        end
+
+        # Protocol-rack moves content-length from headers to body.length —
+        # re-add it so the HTTP/3 response includes the header.
+        if !response_headers.key?("content-length") && response.body&.length
+          response_headers["content-length"] = response.body.length.to_s
+        end
+
+        body = response.body || []
+        connection.send_response(stream, response.status, response_headers, body,
+          head_request: request.head?, trailers: trailers)
+        @request_registry.complete(stream.stream_id)
+      end
+
       def cancelled_stream?(stream_id)
         @cancelled_mutex.synchronize { @cancelled_streams.include?(stream_id) }
       end