raptor 0.20.2 → 0.22.0

data/lib/raptor/server.rb

@@ -182,6 +182,18 @@ module Raptor
         return true
       end
 
+      if listener.is_a?(Binder::H2cListener)
+        @http2.eager_accept(
+          tcp_client,
+          tcp_client.object_id,
+          @reactor,
+          @thread_pool,
+          remote_addr,
+          HTTP_SCHEME
+        )
+        return true
+      end
+
       @http1.eager_accept(
         tcp_client,
         tcp_client.object_id,

data/lib/raptor/version.rb

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

data/lib/raptor.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "raptor/version"
+require_relative "raptor/detached_body"
 
 # Main module for the Raptor web server.
 #

data/sig/generated/raptor/binder.rbs

@@ -1,9 +1,9 @@
 # Generated from lib/raptor/binder.rb with RBS::Inline
 
 module Raptor
-  # Binds `tcp://`, `unix://`, and `ssl://` URIs to listening sockets and
-  # holds them for the server. Reconstructs listeners from inherited file
-  # descriptors when provided (systemd socket activation, hot restart).
+  # Binds TCP, Unix, SSL, and cleartext HTTP/2 URIs to listening sockets
+  # and holds them for the server. Reconstructs listeners from inherited
+  # file descriptors when provided (systemd socket activation, hot restart).
   class Binder
     SOCKET_BACKLOG: ::Integer
 
@@ -27,9 +27,21 @@ module Raptor
       def members: () -> [ :tcp_server, :ssl_context ]
     end
 
-    @uri_listeners: Hash[String, Array[TCPServer | UNIXServer | SslListener]]
+    # Marks a TCPServer as accepting cleartext HTTP/2 connections.
+    class H2cListener < Data
+      attr_reader tcp_server(): untyped
+
+      def self.new: (untyped tcp_server) -> instance
+                  | (tcp_server: untyped) -> instance
+
+      def self.members: () -> [ :tcp_server ]
+
+      def members: () -> [ :tcp_server ]
+    end
+
+    @uri_listeners: Hash[String, Array[TCPServer | UNIXServer | SslListener | H2cListener]]
 
-    @listeners: Array[TCPServer | UNIXServer | SslListener]
+    @listeners: Array[TCPServer | UNIXServer | SslListener | H2cListener]
 
     @inherited_fds: Hash[String, Array[Integer]]
 
@@ -49,7 +61,7 @@ module Raptor
 
     # Returns the array of listening sockets.
     #
-    # @return [Array<TCPServer, UNIXServer, SslListener>]
+    # @return [Array<TCPServer, UNIXServer, SslListener, H2cListener>]
     attr_reader listeners: untyped
 
     # Creates a new Binder and binds each URI. `localhost` expands to both
@@ -66,7 +78,8 @@ module Raptor
     def initialize: (Array[String] bind_uris, ?socket_backlog: Integer, ?inherited_fds: Hash[String, Array[Integer]]) -> void
 
     # Returns the bound addresses as strings: TCP as `host:port`, Unix as
-    # the socket path, SSL as `ssl://host:port`.
+    # the socket path, SSL as `ssl://host:port`, and cleartext HTTP/2 as
+    # `h2c://host:port`.
     #
     # @return [Array<String>]
     #
@@ -124,22 +137,22 @@ module Raptor
     # Creates fresh listeners for the given URI.
     #
     # @param uri [URI] the parsed bind URI
-    # @return [Array<TCPServer, UNIXServer, SslListener>]
+    # @return [Array<TCPServer, UNIXServer, SslListener, H2cListener>]
     # @raise [UnknownBindSchemeError] if the URI scheme is not supported
     #
-    # @rbs (URI::Generic uri) -> Array[TCPServer | UNIXServer | SslListener]
-    def create_listeners: (URI::Generic uri) -> Array[TCPServer | UNIXServer | SslListener]
+    # @rbs (URI::Generic uri) -> Array[TCPServer | UNIXServer | SslListener | H2cListener]
+    def create_listeners: (URI::Generic uri) -> Array[TCPServer | UNIXServer | SslListener | H2cListener]
 
     # Reconstructs listeners for the given URI from inherited file
     # descriptors.
     #
     # @param uri [URI] the parsed bind URI the FDs were bound to
     # @param filenos [Array<Integer>] file descriptors to wrap
-    # @return [Array<TCPServer, UNIXServer, SslListener>]
+    # @return [Array<TCPServer, UNIXServer, SslListener, H2cListener>]
     # @raise [UnknownBindSchemeError] if the URI scheme is not supported
     #
-    # @rbs (URI::Generic uri, Array[Integer] filenos) -> Array[TCPServer | UNIXServer | SslListener]
-    def restore_listeners: (URI::Generic uri, Array[Integer] filenos) -> Array[TCPServer | UNIXServer | SslListener]
+    # @rbs (URI::Generic uri, Array[Integer] filenos) -> Array[TCPServer | UNIXServer | SslListener | H2cListener]
+    def restore_listeners: (URI::Generic uri, Array[Integer] filenos) -> Array[TCPServer | UNIXServer | SslListener | H2cListener]
 
     # Creates TCP server sockets for the given host and port.
     #

data/sig/generated/raptor/detached_body.rbs

@@ -0,0 +1,127 @@
+# Generated from lib/raptor/detached_body.rb with RBS::Inline
+
+module Raptor
+  # A bounded response body that may be written after its application thread
+  # has returned.
+  class DetachedBody
+    DEFAULT_MAX_BUFFER_SIZE: untyped
+
+    # Tracks buffered bytes shared by a group of detached bodies.
+    class Budget
+      @max_size: Integer
+
+      @size: Atom
+
+      # @rbs (Integer max_size) -> void
+      def initialize: (Integer max_size) -> void
+
+      # @rbs (Integer bytes) -> bool
+      def reserve: (Integer bytes) -> bool
+
+      # @rbs (Integer bytes) -> void
+      def release: (Integer bytes) -> void
+    end
+
+    @on_close: (^(Symbol) -> void)?
+
+    @on_open: (^(DetachedBody) -> void)?
+
+    @finished: ^(Symbol) -> void
+
+    @dispatch: ^(Proc) -> void
+
+    @wake: ^() -> void
+
+    @budgets: Array[Budget]
+
+    @state: Atom
+
+    @max_buffer_size: Integer
+
+    # Creates a detached body with a bounded byte buffer.
+    #
+    # @param max_buffer_size [Integer] maximum body bytes waiting to be written
+    # @return [void]
+    #
+    # @rbs (?max_buffer_size: Integer) -> void
+    def initialize: (?max_buffer_size: Integer) -> void
+
+    # Registers a callback for when the server accepts the response stream.
+    #
+    # @yieldparam stream [DetachedBody] the opened response stream
+    # @return [DetachedBody]
+    #
+    # @rbs () { (DetachedBody stream) -> void } -> DetachedBody
+    def on_open: () { (DetachedBody stream) -> void } -> DetachedBody
+
+    # Registers a callback for when the response stream closes.
+    #
+    # @yieldparam reason [Symbol] why the stream closed
+    # @return [DetachedBody]
+    #
+    # @rbs () { (Symbol reason) -> void } -> DetachedBody
+    def on_close: () { (Symbol reason) -> void } -> DetachedBody
+
+    # Adds body bytes without waiting for socket or flow-control capacity.
+    #
+    # @param chunk [String] response body bytes
+    # @return [Symbol] `:accepted`, `:full`, or `:closed`
+    #
+    # @rbs (String chunk) -> Symbol
+    def try_write: (String chunk) -> Symbol
+
+    # Finishes the body after all accepted bytes have been written.
+    #
+    # @param trailers [Hash] trailing response headers
+    # @return [void]
+    #
+    # @rbs (?trailers: Hash[String, String | Array[String]]) -> void
+    def close: (?trailers: Hash[String, String | Array[String]]) -> void
+
+    # Returns whether the stream has closed.
+    #
+    # @return [Boolean]
+    #
+    # @rbs () -> bool
+    def closed?: () -> bool
+
+    # Connects the body to its reactor-owned response stream.
+    #
+    # @rbs (Array[Budget] budgets, ^() -> void wake, ^(Proc) -> void dispatch, ^(Symbol) -> void finished) -> bool
+    def attach: (Array[Budget] budgets, ^() -> void wake, ^(Proc) -> void dispatch, ^(Symbol) -> void finished) -> bool
+
+    # Notifies the application that its response stream is ready.
+    #
+    # @rbs () -> void
+    def open: () -> void
+
+    # Returns the size of the next buffered chunk, 0 when closing, or nil
+    # while waiting for more data.
+    #
+    # @rbs () -> Integer?
+    def next_size: () -> Integer?
+
+    # Removes up to `max_bytes` from the next buffered chunk.
+    #
+    # @rbs (Integer max_bytes) -> String?
+    def shift: (Integer max_bytes) -> String?
+
+    # Returns the response trailers supplied when the body closed.
+    #
+    # @rbs () -> Hash[String, String | Array[String]]
+    def trailers: () -> Hash[String, String | Array[String]]
+
+    # Closes the stream and invokes its callback exactly once.
+    #
+    # @rbs (Symbol reason) -> void
+    def finish: (Symbol reason) -> void
+
+    private
+
+    # @rbs (Integer bytes) -> bool
+    def reserve: (Integer bytes) -> bool
+
+    # @rbs (Integer bytes) -> void
+    def release: (Integer bytes) -> void
+  end
+end

data/sig/generated/raptor/http.rbs

@@ -61,6 +61,18 @@ module Raptor
     # @rbs (Hash[String, untyped] env_template, Integer? max_body_size) -> ^(Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
     def self.parser_worker: (Hash[String, untyped] env_template, Integer? max_body_size) -> ^(Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
 
+    # Calls every `rack.response_finished` callback in reverse
+    # registration order, rescuing any that raise.
+    #
+    # @param env [Hash, nil] the Rack environment
+    # @param status [Integer, nil] the response status code
+    # @param headers [Hash, nil] the response headers
+    # @param error [Exception, nil] any error raised during processing, or nil on success
+    # @return [void]
+    #
+    # @rbs (Hash[String, untyped]? env, Integer? status, Hash[String, String | Array[String]]? headers, Exception? error) -> void
+    def self.call_response_finished: (Hash[String, untyped]? env, Integer? status, Hash[String, String | Array[String]]? headers, Exception? error) -> void
+
     # Writes a Common Log Format entry to `io`. Write failures are silently
     # ignored.
     #

data/sig/generated/raptor/http1.rbs

@@ -78,6 +78,16 @@ module Raptor
     # @rbs (Hash[String, untyped] env) -> bool
     def self.request_smuggling?: (Hash[String, untyped] env) -> bool
 
+    # Encodes one HTTP/1.1 response chunk.
+    #
+    # @rbs (String chunk) -> String
+    def self.encode_chunk: (String chunk) -> String
+
+    # Encodes the final HTTP/1.1 response chunk and its trailers.
+    #
+    # @rbs (Hash[String, String | Array[String]] trailers) -> String
+    def self.encode_trailers: (Hash[String, String | Array[String]] trailers) -> String
+
     # 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
@@ -282,21 +292,23 @@ 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: (TCPSocket socket, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Integer request_count, String remote_addr, String url_scheme) -> bool
+    # @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: (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
 
     # 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: (TCPSocket socket, Hash[String, untyped] env, Hash[Symbol, untyped] parse_data, String? body, Integer request_count, String remote_addr, String url_scheme) -> bool
+    # @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: (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
 
     # Handles an exception raised while processing a request. Fires the
     # `rack.response_finished` callbacks with the error, writes a 500
@@ -419,6 +431,12 @@ module Raptor
     # @rbs (TCPSocket socket, Hash[String, String | Array[String]] hints) -> void
     def send_early_hints: (TCPSocket socket, Hash[String, String | Array[String]] hints) -> void
 
+    # 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: (TCPSocket socket, Integer status, Hash[String, String | Array[String]] headers, chunked: bool, keep_alive: bool) -> void
+
     # Writes a complete HTTP response to the socket.
     #
     # @param socket [TCPSocket] the client socket to write to
@@ -580,18 +598,6 @@ module Raptor
     # @rbs (TCPSocket socket, String response, untyped body, bool use_chunked) -> void
     def write_enumerable_body: (TCPSocket socket, String response, untyped body, bool use_chunked) -> void
 
-    # Calls every `rack.response_finished` callback in reverse
-    # registration order, rescuing any that raise.
-    #
-    # @param env [Hash, nil] the Rack environment
-    # @param status [Integer, nil] the response status code
-    # @param headers [Hash, nil] the response headers
-    # @param error [Exception, nil] any error raised during processing, or nil on success
-    # @return [void]
-    #
-    # @rbs (Hash[String, untyped] env, Integer? status, Hash[String, String | Array[String]]? headers, Exception? error) -> void
-    def call_response_finished: (Hash[String, untyped] env, Integer? status, Hash[String, String | Array[String]]? headers, Exception? error) -> void
-
     # Instance-level wrapper around {Http.write_access_log} that routes to
     # the configured `@access_log_io`.
     #