raptor 0.16.0 → 0.17.0

data/lib/raptor/http1.rb

@@ -21,7 +21,6 @@ module Raptor
     BODY_BUFFER_THRESHOLD = 256 * 1024
     CHUNKED_WRITE_THRESHOLD = 512 * 1024
     FILE_CHUNK_SIZE = 64 * 1024
-    MAX_CHUNK_OVERHEAD = 16 * 1024
     READ_BUFFER_SIZE = 64 * 1024
     RESPONSE_BUFFER_CAPACITY = 4 * 1024
     KEEPALIVE_READ_TIMEOUT = 0.001
@@ -38,7 +37,6 @@ module Raptor
       h[status] = "HTTP/1.1 #{status}#{reason ? " #{reason}" : ""}\r\n".freeze
     end
 
-    STATUS_WITH_NO_ENTITY_BODY = [204, 304, *100..199].freeze
     CONTINUE_RESPONSE = "HTTP/1.1 100 Continue\r\n\r\n"
     BAD_REQUEST_RESPONSE = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     CONTENT_TOO_LARGE_RESPONSE = "HTTP/1.1 413 Content Too Large\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
@@ -48,6 +46,7 @@ module Raptor
     CONNECTION_KEEPALIVE = "keep-alive"
     EXPECT_100_CONTINUE = "100-continue"
     TRANSFER_ENCODING_CHUNKED = "chunked"
+    CHUNKED_TERMINATOR = "0\r\n\r\n"
 
     HTTP_CONNECTION = "HTTP_CONNECTION"
     HTTP_EXPECT = "HTTP_EXPECT"
@@ -56,10 +55,6 @@ module Raptor
     RACK_HIJACKED = "rack.hijacked"
     RACK_HIJACK_IO = "rack.hijack_io"
 
-    ILLEGAL_HEADER_KEY_REGEX = /[\x00-\x20\(\)<>@,;:\\"\/\[\]\?=\{\}\x7F]/
-    ILLEGAL_HEADER_VALUE_REGEX = /[\x00-\x08\x0A-\x1F]/
-    CHUNK_SIZE_REGEX = /\A[0-9A-Fa-f]+\z/
-
     # Returns true when an HTTP/1.1 request lacks a valid `Host` header per
     # RFC 9112 section 3.2, where a valid value is a non-empty single-value
     # line.
@@ -102,59 +97,6 @@ module Raptor
       false
     end
 
-    # Decodes a chunked transfer-encoded body buffer.
-    #
-    # Returns the decoded bytes and a state symbol: `:complete` when the
-    # terminating zero-length chunk and trailer section were fully consumed,
-    # `:too_large` when the decoded size would exceed `max_size`, `:malformed`
-    # when a chunk-size line is not valid hex or chunk framing overhead exceeds
-    # `MAX_CHUNK_OVERHEAD`, or `:incomplete` otherwise.
-    #
-    # @param buffer [String] the raw body buffer to decode
-    # @param max_size [Integer, nil] maximum decoded body size, or nil for unlimited
-    # @return [Array(String, Symbol)] decoded body and completion state
-    #
-    # @rbs (String buffer, ?Integer? max_size) -> [String, Symbol]
-    def self.decode_chunked(buffer, max_size = nil)
-      decoded = String.new
-      offset = 0
-      overhead = 0
-
-      while offset < buffer.bytesize
-        crlf = buffer.index("\r\n", offset)
-        return [decoded, :incomplete] unless crlf
-
-        size_line = buffer.byteslice(offset, crlf - offset)
-        semicolon = size_line.index(";")
-        size_part = semicolon ? size_line.byteslice(0, semicolon) : size_line
-        return [decoded, :malformed] unless size_part.match?(CHUNK_SIZE_REGEX)
-
-        chunk_size = size_part.to_i(16)
-
-        if chunk_size.zero?
-          trailer_offset = crlf + 2
-          loop do
-            trailer_crlf = buffer.index("\r\n", trailer_offset)
-            return [decoded, :incomplete] unless trailer_crlf
-            return [decoded, :complete] if trailer_crlf == trailer_offset
-
-            trailer_offset = trailer_crlf + 2
-          end
-        end
-
-        return [decoded, :too_large] if max_size && (decoded.bytesize + chunk_size) > max_size
-
-        overhead += (crlf - offset) + 4
-        return [decoded, :malformed] if overhead > (decoded.bytesize + chunk_size + MAX_CHUNK_OVERHEAD)
-
-        offset = crlf + 2
-        decoded << buffer.byteslice(offset, chunk_size)
-        offset += chunk_size + 2
-      end
-
-      [decoded, :incomplete]
-    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
@@ -191,7 +133,7 @@ module Raptor
           if max_body_size && parser.content_length > max_body_size
             data.merge(env: env, body: nil, parse_data: parse_data, complete: true, too_large: true)
           elsif parser.chunked?
-            decoded_body, chunked_state = decode_chunked(body_buffer, max_body_size)
+            decoded_body, chunked_state = HttpParser.decode_chunked(body_buffer, max_body_size)
 
             case chunked_state
             when :complete
@@ -479,7 +421,7 @@ module Raptor
       if parser.chunked?
         return :incomplete unless decode_chunked
 
-        body, chunked_state = Http1.decode_chunked(body, @max_body_size)
+        body, chunked_state = HttpParser.decode_chunked(body, @max_body_size)
         case chunked_state
         when :complete
           env.delete(HTTP_TRANSFER_ENCODING)
@@ -581,7 +523,7 @@ module Raptor
           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) unless hijacked
+          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)
         end
@@ -919,11 +861,11 @@ module Raptor
 
       response = +"#{HTTP_11} 103 Early Hints\r\n"
       hints.each do |key, value|
-        next if illegal_header_key?(key)
+        next if HttpParser.illegal_header_key?(key)
 
         values = value.is_a?(Array) ? value : [value]
         values.each do |hint_value|
-          next if illegal_header_value?(hint_value.to_s)
+          next if HttpParser.illegal_header_value?(hint_value.to_s)
 
           response << "#{key.downcase}: #{hint_value}\r\n"
         end
@@ -948,27 +890,29 @@ module Raptor
       validate_status(status)
       response_hijack = headers.is_a?(Hash) ? headers.delete(Rack::RACK_HIJACK) : nil
       headers = normalize_headers(headers)
-      validate_headers(headers, status)
+      no_entity_body = (status >= 100 && status < 200) || status == 204 || status == 304
+      validate_headers(headers, status, no_entity_body)
 
       headers["connection"] = keep_alive ? CONNECTION_KEEPALIVE : CONNECTION_CLOSE
 
       http_version = env[Rack::SERVER_PROTOCOL] == HTTP_11 ? HTTP_11 : HTTP_10
-      no_body = env[Rack::REQUEST_METHOD] == "HEAD" || STATUS_WITH_NO_ENTITY_BODY.include?(status)
+      no_body = env[Rack::REQUEST_METHOD] == "HEAD" || no_entity_body
 
       response = build_status_line(http_version, status)
 
-      cork_socket(socket)
+      corked = !keep_alive
+      cork_socket(socket) if corked
 
       if response_hijack
         write_hijacked_response(socket, response, headers, response_hijack)
       elsif no_body
-        write_no_body_response(socket, response, headers, status)
+        write_no_body_response(socket, response, headers, no_entity_body)
       else
         write_full_response(socket, response, headers, body, http_version)
       end
     ensure
       body.close if body.respond_to?(:close)
-      uncork_socket(socket)
+      uncork_socket(socket) if corked
       socket.flush rescue nil
     end
 
@@ -1001,7 +945,7 @@ module Raptor
       headers.each do |key, value|
         raise TypeError, "header keys must be Strings" unless key.is_a?(String)
 
-        next if illegal_header_key?(key)
+        next if HttpParser.illegal_header_key?(key)
 
         normalized_key = key.match?(/[A-Z]/) ? key.downcase : key
         next if normalized_key.start_with?(RACK_HEADER_PREFIX)
@@ -1017,12 +961,13 @@ module Raptor
     #
     # @param headers [Hash] normalized response headers
     # @param status [Integer] HTTP status code
+    # @param no_entity_body [Boolean] whether the status forbids an entity body
     # @return [void]
     # @raise [ArgumentError] if a forbidden header is present for the status
     #
-    # @rbs (Hash[String, String | Array[String]] headers, Integer status) -> void
-    def validate_headers(headers, status)
-      if STATUS_WITH_NO_ENTITY_BODY.include?(status)
+    # @rbs (Hash[String, String | Array[String]] headers, Integer status, bool no_entity_body) -> void
+    def validate_headers(headers, status, no_entity_body)
+      if no_entity_body
         raise ArgumentError, "content-type must not be present for status #{status}" if headers.key?(Rack::CONTENT_TYPE)
 
         raise ArgumentError, "content-length must not be present for status #{status}" if headers.key?(Rack::CONTENT_LENGTH)
@@ -1055,7 +1000,7 @@ module Raptor
     #
     # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, ^(TCPSocket) -> void response_hijack) -> void
     def write_hijacked_response(socket, response, headers, response_hijack)
-      format_headers(response, headers)
+      HttpParser.format_headers(response, headers)
       response << "\r\n"
       socket_write(socket, response)
       uncork_socket(socket)
@@ -1069,16 +1014,16 @@ module Raptor
     # @param socket [TCPSocket] the client socket
     # @param response [String] the status line accumulated so far
     # @param headers [Hash] normalized response headers
-    # @param status [Integer] HTTP status code
+    # @param no_entity_body [Boolean] whether the response status forbids an entity body
     # @return [void]
     #
-    # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, Integer status) -> void
-    def write_no_body_response(socket, response, headers, status)
-      unless STATUS_WITH_NO_ENTITY_BODY.include?(status)
+    # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, bool no_entity_body) -> void
+    def write_no_body_response(socket, response, headers, no_entity_body)
+      unless no_entity_body
         headers[Rack::CONTENT_LENGTH] = "0" unless headers.key?(Rack::CONTENT_LENGTH) || headers.key?(Rack::TRANSFER_ENCODING)
       end
 
-      format_headers(response, headers)
+      HttpParser.format_headers(response, headers)
       response << "\r\n"
       socket_write(socket, response)
     end
@@ -1097,7 +1042,7 @@ module Raptor
     # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, untyped body, String http_version) -> void
     def write_full_response(socket, response, headers, body, http_version)
       if body.respond_to?(:call)
-        format_headers(response, headers)
+        HttpParser.format_headers(response, headers)
         response << "\r\n"
         socket_write(socket, response)
         uncork_socket(socket)
@@ -1123,7 +1068,7 @@ module Raptor
         headers[Rack::TRANSFER_ENCODING] = TRANSFER_ENCODING_CHUNKED
       end
 
-      format_headers(response, headers)
+      HttpParser.format_headers(response, headers)
       response << "\r\n"
 
       if body.respond_to?(:to_path) && (path = body.to_path) && File.readable?(path)
@@ -1172,13 +1117,13 @@ module Raptor
         if use_chunked
           buffer = response
           while (chunk = file.read(FILE_CHUNK_SIZE))
-            buffer << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n"
+            HttpParser.chunked_encode(buffer, chunk)
             if buffer.bytesize >= CHUNKED_WRITE_THRESHOLD
               socket_write(socket, buffer)
               buffer = +""
             end
           end
-          buffer << "0\r\n\r\n"
+          buffer << CHUNKED_TERMINATOR
           socket_write(socket, buffer)
         elsif content_length && content_length < BODY_BUFFER_THRESHOLD
           response << file.read(content_length)
@@ -1221,7 +1166,8 @@ module Raptor
       raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
       if use_chunked
-        response << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n0\r\n\r\n"
+        HttpParser.chunked_encode(response, chunk)
+        response << CHUNKED_TERMINATOR
         socket_write(socket, response)
       else
         socket_writev(socket, [response, chunk])
@@ -1244,15 +1190,13 @@ module Raptor
         body_array.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
-          next if chunk.empty?
-
-          buffer << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n"
+          HttpParser.chunked_encode(buffer, chunk)
           if buffer.bytesize >= CHUNKED_WRITE_THRESHOLD
             socket_write(socket, buffer)
             buffer = +""
           end
         end
-        buffer << "0\r\n\r\n"
+        buffer << CHUNKED_TERMINATOR
         socket_write(socket, buffer)
       else
         body_array.each do |chunk|
@@ -1275,14 +1219,15 @@ module Raptor
     def write_enumerable_body(socket, response, body, use_chunked)
       if use_chunked
         socket_write(socket, response)
+        buffer = +""
         body.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
-          next if chunk.empty?
-
-          socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+          buffer.clear
+          HttpParser.chunked_encode(buffer, chunk)
+          socket_write(socket, buffer) unless buffer.empty?
         end
-        socket_write(socket, "0\r\n\r\n")
+        socket_write(socket, CHUNKED_TERMINATOR)
       else
         body.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
@@ -1293,72 +1238,6 @@ module Raptor
       end
     end
 
-    # Returns true if the header key contains characters illegal in HTTP headers.
-    #
-    # @param key [String] the header key to check
-    # @return [Boolean] true if the key is illegal
-    #
-    # @rbs (String key) -> bool
-    def illegal_header_key?(key)
-      key.match?(ILLEGAL_HEADER_KEY_REGEX)
-    end
-
-    # Returns true if the header value contains characters illegal in HTTP headers.
-    #
-    # @param value [String] the header value to check
-    # @return [Boolean] true if the value is illegal
-    #
-    # @rbs (String value) -> bool
-    def illegal_header_value?(value)
-      value.match?(ILLEGAL_HEADER_VALUE_REGEX)
-    end
-
-    # Appends normalised header lines to `result`. Skips entries with
-    # illegal keys or values. Array values are written as separate lines.
-    #
-    # @param headers [Hash] normalized response headers
-    # @return [String] formatted header lines, each ending with CRLF
-    #
-    # @rbs (String result, Hash[String, String | Array[String]] headers) -> void
-    def format_headers(result, headers)
-      headers.each do |name, value|
-        next if illegal_header_key?(name)
-
-        if value.is_a?(Array)
-          value.each { |entry| append_header_value(result, name, entry) }
-        else
-          append_header_value(result, name, value)
-        end
-      end
-    end
-
-    # Appends one or more `name: value` header lines to `result`, splitting
-    # newline-joined values across separate lines and skipping empty or
-    # illegal values.
-    #
-    # @param result [String] the buffer to append to
-    # @param name [String] the header name
-    # @param value [Object] the header value (any object responding to `to_s`)
-    # @return [void]
-    #
-    # @rbs (String result, String name, untyped value) -> void
-    def append_header_value(result, name, value)
-      string_value = value.is_a?(String) ? value : value.to_s
-      return if string_value.empty?
-
-      if string_value.include?("\n")
-        string_value.split("\n").each do |line|
-          next if line.empty? || illegal_header_value?(line)
-
-          result << name << ": " << line << "\r\n"
-        end
-      else
-        return if illegal_header_value?(string_value)
-
-        result << name << ": " << string_value << "\r\n"
-      end
-    end
-
     # Calls every `rack.response_finished` callback in reverse
     # registration order, rescuing any that raise.
     #

data/lib/raptor/http2.rb

@@ -229,8 +229,6 @@ module Raptor
     MAX_FRAME_SIZE = 16_384
 
     SERVER_PROTOCOL = "HTTP/2"
-    RACK_HEADER_PREFIX = "rack."
-    HOP_BY_HOP_HEADERS = ["connection", "transfer-encoding", "keep-alive", "upgrade", "proxy-connection"].freeze
 
     REQUEST_PSEUDO_HEADERS = [":method", ":scheme", ":path", ":authority"].freeze
     REQUIRED_REQUEST_PSEUDO_HEADERS = [":method", ":scheme", ":path"].freeze
@@ -766,20 +764,7 @@ module Raptor
     def write_http2_response(socket, writer, flow_control, stream_id, status, headers, body)
       parser = Http2Parser.new
 
-      header_pairs = [[":status", status.to_s]]
-      headers.each do |name, value|
-        lowered = name.downcase
-        next if lowered.start_with?(RACK_HEADER_PREFIX)
-        next if HOP_BY_HOP_HEADERS.include?(lowered)
-
-        if value.is_a?(Array)
-          value.each { |entry| header_pairs << [lowered, entry.to_s] }
-        else
-          header_pairs << [lowered, value.to_s]
-        end
-      end
-
-      encoded_headers = parser.encode_headers(header_pairs)
+      encoded_headers = parser.encode_response_headers(status, headers)
       body_chunks = []
       body_bytes = 0
       body.each do |chunk|

data/lib/raptor/reuseport_bpf.rb

@@ -10,8 +10,8 @@ rescue LoadError
 end
 
 module Raptor
-  # Routes incoming connections across worker processes to the worker with
-  # the lowest reactor backlog.
+  # Routes incoming connections across worker processes using two-choice
+  # load sampling, atomically reserving the selected slot before routing.
   #
   # Auto-enabled on Linux when the `libbpf-ruby` gem is installed and the
   # BPF object file has been compiled. Falls back silently to standard
@@ -47,7 +47,7 @@ module Raptor
       return false unless supported?
 
       @object = LibBPFRuby::Object.new(BPF_OBJECT_PATH)
-      @program_fd = @object.program_fd("select_least_loaded")
+      @program_fd = @object.program_fd("select_less_loaded")
       @socks_fd = @object.map_fd("socks")
       @loads_fd = @object.map_fd("loads")
 
@@ -99,6 +99,7 @@ module Raptor
     def self.enable_load_reporting(worker_index)
       @load_key = [worker_index + 1].pack("L")
       @load_value = String.new("\x00\x00\x00\x00", encoding: Encoding::ASCII_8BIT)
+      @accepted_load_value = String.new("\x00\x00\x00\x00", encoding: Encoding::ASCII_8BIT)
     end
 
     # Publishes this worker's current backlog to the BPF map.
@@ -115,6 +116,22 @@ module Raptor
       LibBPFRuby.map_update(@loads_fd, @load_key, @load_value)
     end
 
+    # Publishes an accept-side backlog estimate. This uses a separate value
+    # buffer because the server and load reporter call into the map from
+    # different threads.
+    #
+    # @param backlog [Integer] the estimated backlog after accepting a socket
+    # @return [void]
+    #
+    # @rbs (Integer backlog) -> void
+    def self.update_accepted_load(backlog)
+      @accepted_load_value.setbyte(0, backlog & 0xff)
+      @accepted_load_value.setbyte(1, (backlog >> 8) & 0xff)
+      @accepted_load_value.setbyte(2, (backlog >> 16) & 0xff)
+      @accepted_load_value.setbyte(3, (backlog >> 24) & 0xff)
+      LibBPFRuby.map_update(@loads_fd, @load_key, @accepted_load_value)
+    end
+
     # Marks a worker's slot as unavailable by parking its load at the
     # sentinel maximum so the BPF program's least-loaded pick skips it.
     #

data/lib/raptor/server.rb

@@ -152,8 +152,9 @@ module Raptor
       end
     end
 
-    # Accepts a connection from the given listener and dispatches it into
-    # the HTTP/1.1 or SSL/HTTP-2 pipeline.
+    # Accepts a connection from the given listener, immediately publishes
+    # the pending work to the BPF map, and dispatches the socket into the
+    # HTTP/1.1 or SSL/HTTP-2 pipeline.
     #
     # @param listener [TCPServer, UNIXServer, Binder::SslListener] the ready listener
     # @return [Boolean] true if a connection was accepted, false if the listener had nothing to dispatch
@@ -172,6 +173,8 @@ module Raptor
         remote_addr = DEFAULT_REMOTE_ADDR
       end
 
+      ReuseportBPF.update_accepted_load(@reactor.backlog + 1) if @bpf_active
+
       if listener.is_a?(Binder::SslListener)
         @thread_pool << proc do
           dispatch_ssl_connection(listener, tcp_client, remote_addr)

data/lib/raptor/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Raptor
-  VERSION = "0.16.0"
+  VERSION = "0.17.0"
 end

data/sig/generated/raptor/cluster.rbs

@@ -26,10 +26,11 @@ module Raptor
     # `[1, HTTP1_RACTOR_COUNT_CAP]`.
     #
     # @param worker_count [Integer] the configured worker count
+    # @param cores [Integer] the available processor count
     # @return [Integer]
     #
-    # @rbs (Integer worker_count) -> Integer
-    def self.default_http1_ractor_count: (Integer worker_count) -> Integer
+    # @rbs (Integer worker_count, ?cores: Integer) -> Integer
+    def self.default_http1_ractor_count: (Integer worker_count, ?cores: Integer) -> Integer
 
     # Returns the default number of HTTP/2 pipeline ractors per
     # worker for the given worker count, rounded from the available
@@ -37,10 +38,11 @@ module Raptor
     # `[1, HTTP2_RACTOR_COUNT_CAP]`.
     #
     # @param worker_count [Integer] the configured worker count
+    # @param cores [Integer] the available processor count
     # @return [Integer]
     #
-    # @rbs (Integer worker_count) -> Integer
-    def self.default_http2_ractor_count: (Integer worker_count) -> Integer
+    # @rbs (Integer worker_count, ?cores: Integer) -> Integer
+    def self.default_http2_ractor_count: (Integer worker_count, ?cores: Integer) -> Integer
 
     @server_port: Integer