raptor 0.2.0 → 0.4.0

data/lib/raptor/reactor.rb

@@ -76,6 +76,7 @@ module Raptor
     # @rbs @socket_to_state: Hash[TCPSocket, Hash[Symbol, untyped]]
     # @rbs @id_to_timeout: Hash[Integer, TimeoutClient]
     # @rbs @id_to_writer: Hash[Integer, untyped]
+    # @rbs @id_to_flow_control: Hash[Integer, untyped]
 
     # Creates a new Reactor instance.
     #
@@ -101,6 +102,7 @@ module Raptor
       @socket_to_state = {}
       @id_to_timeout = {}
       @id_to_writer = {}
+      @id_to_flow_control = {}
     end
 
     # Starts the reactor's main event loop in a new thread.
@@ -117,33 +119,38 @@ module Raptor
         Thread.current.name = self.class.name
 
         until @queue.closed? && @queue.empty?
-          timeout = @timeouts.min&.timeout(Process.clock_gettime(Process::CLOCK_MONOTONIC))
-          @selector.select(timeout) do |monitor|
-            wakeup!(monitor.value)
-          end
-
-          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          expired = []
-          @timeouts.traverse do |to_client|
-            break unless to_client.timeout(now) == 0
-
-            expired << to_client
-          end
-
-          expired.each do |to_client|
-            @timeouts.delete!(to_client)
-            id = to_client.client_data[:id]
-            @id_to_timeout.delete(id)
-            socket = @id_to_socket[id]
-            next unless socket
-
-            @selector.deregister(socket)
-            socket.write(TIMEOUT_RESPONSE) rescue nil
-            cleanup(socket)
-          end
-
-          until @queue.empty?
-            register(@queue.pop)
+          begin
+            timeout = @timeouts.min&.timeout(Process.clock_gettime(Process::CLOCK_MONOTONIC))
+            @selector.select(timeout) do |monitor|
+              wakeup!(monitor.value)
+            end
+
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            expired = []
+            @timeouts.traverse do |to_client|
+              break unless to_client.timeout(now) == 0
+
+              expired << to_client
+            end
+
+            expired.each do |to_client|
+              @timeouts.delete!(to_client)
+              id = to_client.client_data[:id]
+              @id_to_timeout.delete(id)
+              socket = @id_to_socket[id]
+              next unless socket
+
+              @selector.deregister(socket)
+              socket.write(TIMEOUT_RESPONSE) rescue nil
+              cleanup(socket)
+            end
+
+            until @queue.empty?
+              register(@queue.pop)
+            end
+          rescue => error
+            warn "#{Thread.current.name} rescued:"
+            warn error.full_message
           end
         end
 
@@ -163,9 +170,11 @@ module Raptor
       socket = state[:socket]
       state.delete(:socket)
       writer = state.delete(:writer)
+      flow_control = state.delete(:flow_control)
       @id_to_socket[state[:id]] = socket
       @socket_to_state[socket] = state
       @id_to_writer[state[:id]] = writer if writer
+      @id_to_flow_control[state[:id]] = flow_control if flow_control
 
       read_and_queue_for_parse(socket, state)
     end
@@ -262,6 +271,18 @@ module Raptor
       @id_to_writer[id]
     end
 
+    # Returns the flow controller associated with a given connection, if one
+    # was supplied when the connection was added. Used by HTTP/2 stream
+    # dispatchers to honour the peer's flow-control windows.
+    #
+    # @param id [Integer] unique client identifier
+    # @return [Object, nil] the flow controller, if found
+    #
+    # @rbs (Integer id) -> untyped?
+    def flow_control_for(id)
+      @id_to_flow_control[id]
+    end
+
     # Updates connection state for an HTTP/2 connection after frame processing.
     #
     # Re-registers the socket with the selector for further reads and stores
@@ -282,6 +303,24 @@ module Raptor
       socket.close
     end
 
+    # Closes the socket for the given connection and drops all reactor state
+    # associated with it. Used to terminate HTTP/2 connections after sending
+    # a GOAWAY frame.
+    #
+    # @param id [Integer] unique client identifier
+    # @return [void]
+    #
+    # @rbs (Integer id) -> void
+    def close_connection(id)
+      socket = @id_to_socket.delete(id)
+      return unless socket
+
+      @socket_to_state.delete(socket)
+      @id_to_writer.delete(id)
+      @id_to_flow_control.delete(id)
+      socket.close rescue nil
+    end
+
     # Initiates reactor shutdown.
     #
     # Closes the registration queue and wakes up the selector to begin
@@ -385,6 +424,7 @@ module Raptor
       state = @socket_to_state.delete(socket)
       @id_to_socket.delete(state[:id])
       @id_to_writer.delete(state[:id])
+      @id_to_flow_control.delete(state[:id])
       socket.close
     end
 

data/lib/raptor/request.rb

@@ -3,7 +3,9 @@
 
 require "socket"
 require "stringio"
+require "tempfile"
 
+require "atomic-ruby/atomic_boolean"
 require "rack"
 
 require_relative "raptor_http"
@@ -38,7 +40,9 @@ module Raptor
     end
 
     STATUS_WITH_NO_ENTITY_BODY = Set.new([204, 304, *100..199]).freeze
-    ERROR_RESPONSE_500 = "HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+    BAD_REQUEST_RESPONSE = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+    INTERNAL_SERVER_ERROR_RESPONSE = "HTTP/1.1 500 Internal Server Error\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"
 
     CONNECTION_CLOSE = "close"
     CONNECTION_KEEPALIVE = "keep-alive"
@@ -61,46 +65,97 @@ module Raptor
 
     # Decodes a chunked transfer-encoded body buffer.
     #
-    # Returns the decoded bytes and a flag indicating whether the terminating
-    # zero-length chunk was found. The decoder stops at the first unparseable
-    # boundary (incomplete CRLF) or zero-length chunk.
+    # Returns the decoded bytes and a state symbol: `:complete` when the
+    # terminating zero-length chunk was found, `:too_large` when the decoded
+    # size would exceed `max_size`, or `:incomplete` otherwise.
     #
     # @param buffer [String] the raw body buffer to decode
-    # @return [Array(String, Boolean)] decoded body and completion flag
+    # @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) -> [String, bool]
-    def self.decode_chunked(buffer)
+    # @rbs (String buffer, ?Integer? max_size) -> [String, Symbol]
+    def self.decode_chunked(buffer, max_size = nil)
       decoded = String.new
       offset = 0
 
       while offset < buffer.bytesize
         crlf = buffer.index("\r\n", offset)
-        return [decoded, false] unless crlf
+        return [decoded, :incomplete] unless crlf
 
         chunk_size = buffer.byteslice(offset, crlf - offset).to_i(16)
-        return [decoded, true] if chunk_size == 0
+        return [decoded, :complete] if chunk_size == 0
+        return [decoded, :too_large] if max_size && decoded.bytesize + chunk_size > max_size
 
         offset = crlf + 2
         decoded << buffer.byteslice(offset, chunk_size)
         offset += chunk_size + 2
       end
 
-      [decoded, false]
+      [decoded, :incomplete]
+    end
+
+    # Writes a string to the socket, retrying on partial writes and flow control blocks.
+    #
+    # Uses write_nonblock with `WRITE_TIMEOUT` to avoid blocking the thread
+    # indefinitely on slow clients.
+    #
+    # @param socket [TCPSocket] the socket to write to
+    # @param string [String] the data to write
+    # @return [void]
+    # @raise [WriteError] if the socket is not writable within the timeout or raises IOError
+    #
+    # @rbs (TCPSocket socket, String string) -> void
+    def self.socket_write(socket, string)
+      bytes = 0
+      byte_size = string.bytesize
+
+      while bytes < byte_size
+        begin
+          bytes += socket.write_nonblock(bytes.zero? ? string : string.byteslice(bytes..-1))
+        rescue IO::WaitWritable
+          raise WriteError unless socket.wait_writable(WRITE_TIMEOUT)
+          retry
+        rescue IOError
+          raise WriteError
+        end
+      end
     end
 
     # @rbs @app: ^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped]
     # @rbs @server_port: Integer
+    # @rbs @max_body_size: Integer?
+    # @rbs @body_spool_threshold: Integer?
+    # @rbs @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
+    # @rbs @running: AtomicBoolean
 
     # Creates a new Request handler.
     #
     # @param app [#call] the Rack application to dispatch complete requests to
     # @param server_port [Integer] port number used to populate SERVER_PORT in the Rack env
+    # @param client_options [Hash] client limits configuration
+    # @option client_options [Integer, nil] :max_body_size maximum request body size in bytes
+    # @option client_options [Integer, nil] :body_spool_threshold spool bodies larger than this to a tempfile
+    # @param on_error [#call, nil] callback invoked with (env, exception) when the Rack app raises
     # @return [void]
     #
-    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port) -> void
-    def initialize(app, server_port)
+    # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, Integer server_port, ?client_options: Hash[Symbol, untyped], ?on_error: ^(Hash[String, untyped]?, Exception) -> void | nil) -> void
+    def initialize(app, server_port, client_options: {}, on_error: nil)
       @app = app
       @server_port = server_port
+      @max_body_size = client_options[:max_body_size]
+      @body_spool_threshold = client_options[:body_spool_threshold]
+      @on_error = on_error
+      @running = AtomicBoolean.new(true)
+    end
+
+    # Signals eager keep-alive loops to stop processing further requests on
+    # their connections. In-flight requests complete normally.
+    #
+    # @return [void]
+    #
+    # @rbs () -> void
+    def shutdown
+      @running.make_false
     end
 
     # Eagerly reads and parses the first request on a freshly accepted
@@ -141,7 +196,12 @@ module Raptor
 
       parser = HttpParser.new
       env = {}
-      nread = parser.execute(env, buffer, 0)
+      nread = begin
+        parser.execute(env, buffer, 0)
+      rescue HttpParserError
+        reject_malformed(socket)
+        return
+      end
       parse_data = { parse_count: 1, content_length: parser.content_length }
 
       body = nil
@@ -149,12 +209,21 @@ module Raptor
         fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, 0, remote_addr, url_scheme, persisted: false)
         return
       elsif parser.has_body?
+        if @max_body_size && parser.content_length > @max_body_size
+          reject_oversized(socket)
+          return
+        end
+
         body = buffer.byteslice(nread..-1) || ""
 
         if env[HTTP_TRANSFER_ENCODING]&.include?(TRANSFER_ENCODING_CHUNKED)
-          body, chunked_complete = Request.decode_chunked(body)
-          if chunked_complete
+          body, chunked_state = Request.decode_chunked(body, @max_body_size)
+          case chunked_state
+          when :complete
             env.delete(HTTP_TRANSFER_ENCODING)
+          when :too_large
+            reject_oversized(socket)
+            return
           else
             fallback_to_reactor(socket, id, buffer, env, parse_data, reactor, 0, remote_addr, url_scheme, persisted: false)
             return
@@ -180,12 +249,18 @@ module Raptor
     #
     # @rbs () -> ^(Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
     def http_parser_worker
+      max_body_size = @max_body_size
+
       proc do |data|
         next Raptor::Http2.process_frames(data) if data[:protocol] == :http2
 
         parser = Raptor::HttpParser.new
         env = {}
-        nread = parser.execute(env, data[:buffer], 0)
+        nread = begin
+          parser.execute(env, data[:buffer], 0)
+        rescue Raptor::HttpParserError
+          next Ractor.make_shareable(data.merge(complete: true, malformed: true))
+        end
         parse_data = if data[:parse_data]
           data[:parse_data].dup
         else
@@ -197,12 +272,17 @@ module Raptor
           if parser.has_body?
             body_buffer = data[:buffer].byteslice(nread..-1) || ""
 
-            if env[HTTP_TRANSFER_ENCODING]&.include?(TRANSFER_ENCODING_CHUNKED)
-              decoded_body, chunked_complete = Raptor::Request.decode_chunked(body_buffer)
+            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 env[HTTP_TRANSFER_ENCODING]&.include?(TRANSFER_ENCODING_CHUNKED)
+              decoded_body, chunked_state = Raptor::Request.decode_chunked(body_buffer, max_body_size)
 
-              if chunked_complete
+              case chunked_state
+              when :complete
                 env.delete(HTTP_TRANSFER_ENCODING)
                 data.merge(env: env, body: decoded_body, parse_data: parse_data, complete: true)
+              when :too_large
+                data.merge(env: env, body: nil, parse_data: parse_data, complete: true, too_large: true)
               else
                 data.merge(env: env, parse_data: parse_data)
               end
@@ -233,6 +313,18 @@ module Raptor
     #
     # @rbs (Hash[Symbol, untyped] parsed_request, Reactor reactor, AtomicThreadPool thread_pool) -> void
     def handle_parsed_request(parsed_request, reactor, thread_pool)
+      if parsed_request[:too_large]
+        socket = reactor.remove(parsed_request[:id])
+        reject_oversized(socket) if socket
+        return
+      end
+
+      if parsed_request[:malformed]
+        socket = reactor.remove(parsed_request[:id])
+        reject_malformed(socket) if socket
+        return
+      end
+
       unless parsed_request[:complete]
         reactor.update_state(parsed_request)
       else
@@ -322,10 +414,18 @@ module Raptor
         keep_alive && !hijacked
       rescue => error
         call_response_finished(rack_env, status, headers, error) if rack_env
-        socket.write(ERROR_RESPONSE_500) rescue nil unless response_started || hijacked
+        socket.write(INTERNAL_SERVER_ERROR_RESPONSE) rescue nil unless response_started || hijacked
         keep_alive = false
-        raise
+
+        if @on_error
+          @on_error.call(rack_env, error) rescue nil
+        else
+          raise
+        end
       ensure
+        rack_input = rack_env && rack_env[Rack::RACK_INPUT]
+        rack_input.close! rescue nil if rack_input.respond_to?(:close!)
+
         unless hijacked || keep_alive
           socket.close rescue nil
         end
@@ -350,6 +450,11 @@ module Raptor
     # @rbs (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, Integer request_count, String remote_addr, String url_scheme) -> void
     def eager_keepalive(socket, id, reactor, thread_pool, request_count, remote_addr, url_scheme)
       loop do
+        unless @running.true?
+          socket.close rescue nil
+          return
+        end
+
         unless socket.wait_readable(KEEPALIVE_READ_TIMEOUT)
           reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
           return
@@ -374,7 +479,12 @@ module Raptor
 
         parser = HttpParser.new
         env = {}
-        nread = parser.execute(env, buffer, 0)
+        nread = begin
+          parser.execute(env, buffer, 0)
+        rescue HttpParserError
+          reject_malformed(socket)
+          return
+        end
         parse_data = { parse_count: 1, content_length: parser.content_length }
 
         body = nil
@@ -459,6 +569,30 @@ module Raptor
       reactor.update_state(Ractor.make_shareable(state))
     end
 
+    # Writes a 413 response and closes the socket. Used when a request body
+    # exceeds the configured maximum size.
+    #
+    # @param socket [TCPSocket] the client socket
+    # @return [void]
+    #
+    # @rbs (TCPSocket socket) -> void
+    def reject_oversized(socket)
+      socket.write(CONTENT_TOO_LARGE_RESPONSE) rescue nil
+      socket.close rescue nil
+    end
+
+    # Writes a 400 response and closes the socket. Used when the HTTP parser
+    # rejects the request line or headers.
+    #
+    # @param socket [TCPSocket] the client socket
+    # @return [void]
+    #
+    # @rbs (TCPSocket socket) -> void
+    def reject_malformed(socket)
+      socket.write(BAD_REQUEST_RESPONSE) rescue nil
+      socket.close rescue nil
+    end
+
     # Builds a Rack environment hash from parsed HTTP request data.
     #
     # Populates all required Rack env keys including rack.* keys, REMOTE_ADDR,
@@ -476,7 +610,7 @@ module Raptor
     def build_rack_env(env, parse_data, body, socket, remote_addr: "127.0.0.1", url_scheme: HTTP_SCHEME)
       env[Rack::RACK_VERSION] = Rack::VERSION
       env[Rack::RACK_URL_SCHEME] = url_scheme
-      env[Rack::RACK_INPUT] = (body ? StringIO.new(body) : StringIO.new).set_encoding(Encoding::ASCII_8BIT)
+      env[Rack::RACK_INPUT] = build_rack_input(body)
       env[Rack::RACK_ERRORS] = $stderr
       env[Rack::RACK_RESPONSE_FINISHED] = []
 
@@ -520,6 +654,26 @@ module Raptor
       env
     end
 
+    # Builds the `rack.input` IO object for the request body. Returns an
+    # in-memory StringIO for bodies up to the spool threshold, or a Tempfile
+    # for larger bodies to bound per-worker memory.
+    #
+    # @param body [String, nil] decoded request body
+    # @return [IO] an IO-like object positioned at the start of the body
+    #
+    # @rbs (String? body) -> IO
+    def build_rack_input(body)
+      if body && @body_spool_threshold && body.bytesize > @body_spool_threshold
+        tempfile = Tempfile.new("raptor-body")
+        tempfile.binmode
+        tempfile.write(body)
+        tempfile.rewind
+        tempfile
+      else
+        (body ? StringIO.new(body) : StringIO.new).set_encoding(Encoding::ASCII_8BIT)
+      end
+    end
+
     # Determines whether the connection should be kept alive after the response.
     #
     # Returns false if the request limit has been reached. For HTTP/1.1, keep-alive
@@ -568,7 +722,7 @@ module Raptor
       end
       response << "\r\n"
 
-      socket_write(socket, response)
+      Request.socket_write(socket, response)
     end
 
     # Writes a complete HTTP response to the socket.
@@ -701,7 +855,7 @@ module Raptor
     def write_hijacked_response(socket, response, headers, response_hijack)
       response << format_headers(headers)
       response << "\r\n"
-      socket_write(socket, response)
+      Request.socket_write(socket, response)
       uncork_socket(socket)
       response_hijack.call(socket)
     end
@@ -726,7 +880,7 @@ module Raptor
 
       response << format_headers(headers)
       response << "\r\n"
-      socket_write(socket, response)
+      Request.socket_write(socket, response)
     end
 
     # Writes a complete response with a body.
@@ -748,7 +902,7 @@ module Raptor
       if body.respond_to?(:call)
         response << format_headers(headers)
         response << "\r\n"
-        socket_write(socket, response)
+        Request.socket_write(socket, response)
         uncork_socket(socket)
         body.call(socket)
         return
@@ -785,7 +939,7 @@ module Raptor
         raise TypeError, "body must respond to each, to_ary, or to_path"
       end
 
-      socket_write(socket, "0\r\n\r\n") if use_chunked
+      Request.socket_write(socket, "0\r\n\r\n") if use_chunked
     end
 
     # Calculates content length from an array or file body without consuming it.
@@ -825,15 +979,15 @@ module Raptor
     def write_file_body(socket, response, path, content_length, use_chunked)
       File.open(path, "rb") do |file|
         if use_chunked
-          socket_write(socket, response)
+          Request.socket_write(socket, response)
           while (chunk = file.read(FILE_CHUNK_SIZE))
-            socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+            Request.socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
           end
         elsif content_length && content_length < BODY_BUFFER_THRESHOLD
           response << file.read(content_length)
-          socket_write(socket, response)
+          Request.socket_write(socket, response)
         else
-          socket_write(socket, response)
+          Request.socket_write(socket, response)
           IO.copy_stream(file, socket)
         end
       end
@@ -876,12 +1030,12 @@ module Raptor
 
       if use_chunked
         response << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
-        socket_write(socket, response)
+        Request.socket_write(socket, response)
       elsif chunk.bytesize < BODY_BUFFER_THRESHOLD
-        socket_write(socket, response << chunk)
+        Request.socket_write(socket, response << chunk)
       else
-        socket_write(socket, response)
-        socket_write(socket, chunk)
+        Request.socket_write(socket, response)
+        Request.socket_write(socket, chunk)
       end
     end
 
@@ -897,13 +1051,13 @@ module Raptor
     # @rbs (TCPSocket socket, String response, Array[String] body_array, bool use_chunked) -> void
     def write_multiple_chunks(socket, response, body_array, use_chunked)
       if use_chunked
-        socket_write(socket, response)
+        Request.socket_write(socket, response)
         body_array.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")
+          Request.socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
         end
       else
         body_array.each do |chunk|
@@ -911,7 +1065,7 @@ module Raptor
 
           response << chunk
         end
-        socket_write(socket, response)
+        Request.socket_write(socket, response)
       end
     end
 
@@ -927,13 +1081,13 @@ module Raptor
     # @rbs (TCPSocket socket, String response, untyped body, bool use_chunked) -> void
     def write_enumerable_body(socket, response, body, use_chunked)
       if use_chunked
-        socket_write(socket, response)
+        Request.socket_write(socket, response)
         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")
+          Request.socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
         end
       else
         body.each do |chunk|
@@ -941,7 +1095,7 @@ module Raptor
 
           response << chunk
         end
-        socket_write(socket, response)
+        Request.socket_write(socket, response)
       end
     end
 
@@ -1014,33 +1168,6 @@ module Raptor
       end
     end
 
-    # Writes a string to the socket, retrying on partial writes and flow control blocks.
-    #
-    # Uses write_nonblock with a 5-second writable timeout to avoid blocking the
-    # thread indefinitely on slow clients.
-    #
-    # @param socket [TCPSocket] the socket to write to
-    # @param string [String] the data to write
-    # @return [void]
-    # @raise [WriteError] if the socket is not writable within the timeout or raises IOError
-    #
-    # @rbs (TCPSocket socket, String string) -> void
-    def socket_write(socket, string)
-      bytes = 0
-      byte_size = string.bytesize
-
-      while bytes < byte_size
-        begin
-          bytes += socket.write_nonblock(bytes.zero? ? string : string.byteslice(bytes..-1))
-        rescue IO::WaitWritable
-          raise WriteError unless socket.wait_writable(WRITE_TIMEOUT)
-          retry
-        rescue IOError
-          raise WriteError
-        end
-      end
-    end
-
     if Socket.const_defined?(:TCP_CORK)
       # Enables TCP_CORK on the socket to batch outgoing packets into fewer segments.
       #