raptor 0.23.0 → 0.25.0

data/ext/raptor_http/raptor_http.c

@@ -15,8 +15,8 @@
 #define MAX_FIELD_NAME 256
 #define MAX_FIELD_VALUE (80 * 1024)
 
-// Upper bound on chunk-size lines, extensions and CRLFs a chunked body may
-// carry beyond its payload before it is rejected as malformed.
+// Bounds each chunk-size line and the terminal chunk/trailer section, including
+// CRLFs. Also limits cumulative nonterminal overhead beyond the payload size.
 #define MAX_CHUNK_OVERHEAD (16 * 1024)
 
 #define FLAG_CHUNKED  0x1
@@ -34,6 +34,7 @@ typedef struct {
   int64_t content_len;
   unsigned int flags;
   VALUE request;
+  VALUE underscored_headers;
   // Scratch space for the env key: "HTTP_" prefix + field name + NUL.
   char buf[MAX_FIELD_NAME + 6];
 } raptor_parser;
@@ -125,13 +126,6 @@ static VALUE intern_field(const char *buf, size_t len) {
   return rb_enc_interned_str(buf, len, rb_utf8_encoding());
 }
 
-static inline void upcase_header_char(char *c) {
-  if (*c >= 'a' && *c <= 'z')
-    *c &= ~0x20;
-  else if (*c == '-')
-    *c = '_';
-}
-
 static int contains_chunked(const char *value, long len) {
   static const char chunked[] = "chunked";
   static const long chunked_len = sizeof(chunked) - 1;
@@ -159,6 +153,65 @@ static int64_t parse_content_length(const char *value, long len) {
   return content_len;
 }
 
+static void parse_header(raptor_parser *parser, const char *field, const char *value, size_t value_len) {
+  size_t field_len = parser->field_len;
+  if (field_len == 0 || field_len > MAX_FIELD_NAME)
+    rb_raise(eHttpParserError, "invalid field name length");
+  if (value_len > MAX_FIELD_VALUE)
+    rb_raise(eHttpParserError, "field value too long");
+
+  int underscored = 0;
+  char *normalized = parser->buf + 5;
+  for (size_t i = 0; i < field_len; i++) {
+    char c = field[i];
+    if (c == '_') underscored = 1;
+    normalized[i] = c == '-' ? '_' : (c >= 'a' && c <= 'z' ? c & ~0x20 : c);
+  }
+  int content_length = field_len == 14 && memcmp(normalized, "CONTENT_LENGTH", 14) == 0;
+  int content_type = field_len == 12 && memcmp(normalized, "CONTENT_TYPE", 12) == 0;
+  int transfer_encoding = field_len == 17 && memcmp(normalized, "TRANSFER_ENCODING", 17) == 0;
+  if (underscored && (content_length || transfer_encoding))
+    rb_raise(eHttpParserError, "invalid framing header name");
+
+  size_t key_len = field_len;
+  if (content_length || content_type) {
+    memmove(parser->buf, normalized, field_len);
+  } else {
+    memcpy(parser->buf, "HTTP_", 5);
+    key_len += 5;
+  }
+  VALUE key = intern_field(parser->buf, key_len);
+  VALUE existing = rb_hash_aref(parser->request, key);
+  int existing_underscored = !NIL_P(parser->underscored_headers) &&
+                            RTEST(rb_hash_aref(parser->underscored_headers, key));
+  // Canonical names win in either order; true duplicates still merge.
+  if (underscored) {
+    if (!NIL_P(existing) && !existing_underscored) return;
+    if (NIL_P(parser->underscored_headers)) parser->underscored_headers = rb_hash_new();
+    rb_hash_aset(parser->underscored_headers, key, Qtrue);
+  } else if (existing_underscored) {
+    existing = Qnil;
+    rb_hash_delete(parser->underscored_headers, key);
+  }
+
+  while (value_len > 0 && (value[value_len - 1] == ' ' || value[value_len - 1] == '\t'))
+    value_len--;
+  if (content_length) {
+    parser->content_len = parse_content_length(value, (long)value_len);
+    if (parser->content_len > 0) parser->flags |= FLAG_HAS_BODY;
+  } else if (transfer_encoding && contains_chunked(value, (long)value_len)) {
+    parser->flags |= FLAG_CHUNKED | FLAG_HAS_BODY;
+    parser->content_len = 0;
+  }
+
+  if (!NIL_P(existing)) {
+    rb_str_cat(existing, ", ", 2);
+    rb_str_cat(existing, value, (long)value_len);
+  } else {
+    rb_hash_aset(parser->request, key, rb_str_new(value, (long)value_len));
+  }
+}
+
 static const int raptor_parser_start = 1;
 
 static size_t raptor_parser_execute(raptor_parser *parser, const char *buffer, size_t len) {
@@ -385,122 +438,12 @@ tr18:
 tr26:
 	{ MARK(mark, p); }
 	{
-    if (parser->field_len == 0 || parser->field_len > MAX_FIELD_NAME)
-      rb_raise(eHttpParserError, "invalid field name length");
-
-    size_t value_len = LEN(mark, p);
-    if (value_len > MAX_FIELD_VALUE)
-      rb_raise(eHttpParserError, "field value too long");
-
-    const char *field_ptr = PTR_TO(field_start);
-
-    int needs_http_prefix = 1;
-    if (parser->field_len == 14 && memcmp(field_ptr, "CONTENT_LENGTH", 14) == 0)
-      needs_http_prefix = 0;
-    else if (parser->field_len == 12 && memcmp(field_ptr, "CONTENT_TYPE", 12) == 0)
-      needs_http_prefix = 0;
-
-    size_t key_len;
-    if (needs_http_prefix) {
-      memcpy(parser->buf, "HTTP_", 5);
-      memcpy(parser->buf + 5, field_ptr, parser->field_len);
-      key_len = 5 + parser->field_len;
-      parser->buf[key_len] = '\0';
-    } else {
-      memcpy(parser->buf, field_ptr, parser->field_len);
-      key_len = parser->field_len;
-      parser->buf[key_len] = '\0';
-    }
-
-    VALUE key = intern_field(parser->buf, key_len);
-    VALUE value = rb_str_new(PTR_TO(mark), value_len);
-
-    char *value_ptr = RSTRING_PTR(value);
-    long value_real_len = RSTRING_LEN(value);
-    while (value_real_len > 0 && (value_ptr[value_real_len - 1] == ' ' ||
-                                    value_ptr[value_real_len - 1] == '\t'))
-      value_real_len--;
-    rb_str_set_len(value, value_real_len);
-
-    if (!needs_http_prefix && parser->field_len == 14) {
-      parser->content_len = parse_content_length(value_ptr, value_real_len);
-      if (parser->content_len > 0)
-        parser->flags |= FLAG_HAS_BODY;
-    } else if (needs_http_prefix && parser->field_len == 17 &&
-               memcmp(field_ptr, "TRANSFER_ENCODING", 17) == 0) {
-      if (contains_chunked(value_ptr, value_real_len)) {
-        parser->flags |= FLAG_CHUNKED | FLAG_HAS_BODY;
-        parser->content_len = 0;
-      }
-    }
-
-    VALUE existing = rb_hash_aref(parser->request, key);
-    if (!NIL_P(existing)) {
-      rb_str_cat(existing, ", ", 2);
-      rb_str_append(existing, value);
-    } else {
-      rb_hash_aset(parser->request, key, value);
-    }
+    parse_header(parser, PTR_TO(field_start), PTR_TO(mark), LEN(mark, p));
   }
 	goto st14;
 tr29:
 	{
-    if (parser->field_len == 0 || parser->field_len > MAX_FIELD_NAME)
-      rb_raise(eHttpParserError, "invalid field name length");
-
-    size_t value_len = LEN(mark, p);
-    if (value_len > MAX_FIELD_VALUE)
-      rb_raise(eHttpParserError, "field value too long");
-
-    const char *field_ptr = PTR_TO(field_start);
-
-    int needs_http_prefix = 1;
-    if (parser->field_len == 14 && memcmp(field_ptr, "CONTENT_LENGTH", 14) == 0)
-      needs_http_prefix = 0;
-    else if (parser->field_len == 12 && memcmp(field_ptr, "CONTENT_TYPE", 12) == 0)
-      needs_http_prefix = 0;
-
-    size_t key_len;
-    if (needs_http_prefix) {
-      memcpy(parser->buf, "HTTP_", 5);
-      memcpy(parser->buf + 5, field_ptr, parser->field_len);
-      key_len = 5 + parser->field_len;
-      parser->buf[key_len] = '\0';
-    } else {
-      memcpy(parser->buf, field_ptr, parser->field_len);
-      key_len = parser->field_len;
-      parser->buf[key_len] = '\0';
-    }
-
-    VALUE key = intern_field(parser->buf, key_len);
-    VALUE value = rb_str_new(PTR_TO(mark), value_len);
-
-    char *value_ptr = RSTRING_PTR(value);
-    long value_real_len = RSTRING_LEN(value);
-    while (value_real_len > 0 && (value_ptr[value_real_len - 1] == ' ' ||
-                                    value_ptr[value_real_len - 1] == '\t'))
-      value_real_len--;
-    rb_str_set_len(value, value_real_len);
-
-    if (!needs_http_prefix && parser->field_len == 14) {
-      parser->content_len = parse_content_length(value_ptr, value_real_len);
-      if (parser->content_len > 0)
-        parser->flags |= FLAG_HAS_BODY;
-    } else if (needs_http_prefix && parser->field_len == 17 &&
-               memcmp(field_ptr, "TRANSFER_ENCODING", 17) == 0) {
-      if (contains_chunked(value_ptr, value_real_len)) {
-        parser->flags |= FLAG_CHUNKED | FLAG_HAS_BODY;
-        parser->content_len = 0;
-      }
-    }
-
-    VALUE existing = rb_hash_aref(parser->request, key);
-    if (!NIL_P(existing)) {
-      rb_str_cat(existing, ", ", 2);
-      rb_str_append(existing, value);
-    } else {
-      rb_hash_aset(parser->request, key, value);
-    }
+    parse_header(parser, PTR_TO(field_start), PTR_TO(mark), LEN(mark, p));
   }
 	goto st14;
 st14:
@@ -560,10 +503,8 @@ case 46:
 	goto st0;
 tr21:
 	{ MARK(field_start, p); }
-	{ upcase_header_char((char *)p); }
 	goto st17;
 tr23:
-	{ upcase_header_char((char *)p); }
 	goto st17;
 st17:
 	if ( ++p == pe )
@@ -606,6 +547,7 @@ st18:
 		goto _test_eof18;
 case 18:
 	switch( (*p) ) {
+		case 9: goto tr27;
 		case 13: goto tr26;
 		case 32: goto tr27;
 		case 127: goto st0;
@@ -1219,11 +1161,13 @@ static void raptor_parser_init(raptor_parser *parser) {
   parser->content_len = 0;
   parser->flags = 0;
   parser->request = Qnil;
+  parser->underscored_headers = Qnil;
 }
 
 static void parser_mark(void *ptr) {
   raptor_parser *parser = ptr;
   rb_gc_mark(parser->request);
+  rb_gc_mark(parser->underscored_headers);
 }
 
 static size_t parser_memsize(const void *ptr) {
@@ -1325,6 +1269,9 @@ static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
 
   while (offset < len) {
     const char *crlf = find_crlf(buf + offset, len - offset);
+    size_t line_bytes = crlf ? (size_t)(crlf - (buf + offset)) + 2 : len - offset;
+    if (line_bytes > MAX_CHUNK_OVERHEAD)
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
     if (!crlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
 
     size_t line_len = (size_t)(crlf - (buf + offset));
@@ -1354,6 +1301,9 @@ static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
       while (1) {
         if (trailer_offset >= len) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
         const char *tcrlf = find_crlf(buf + trailer_offset, len - trailer_offset);
+        size_t terminal_bytes = tcrlf ? (size_t)(tcrlf - (buf + offset)) + 2 : len - offset;
+        if (terminal_bytes > MAX_CHUNK_OVERHEAD)
+          return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
         if (!tcrlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
         if (tcrlf == buf + trailer_offset) return rb_ary_new_from_args(3, decoded, ID2SYM(id_complete), SIZET2NUM(trailer_offset + 2));
         trailer_offset = (size_t)(tcrlf - buf) + 2;
@@ -1375,6 +1325,15 @@ static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
     size_t bytes_to_copy = (size_t)chunk_size < available ? (size_t)chunk_size : available;
     rb_str_cat(decoded, buf + data_offset, (long)bytes_to_copy);
 
+    if (available <= (size_t)chunk_size)
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+    if (buf[data_offset + (size_t)chunk_size] != '\r')
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+    if (available == (size_t)chunk_size + 1)
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+    if (buf[data_offset + (size_t)chunk_size + 1] != '\n')
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+
     offset = data_offset + (size_t)chunk_size + 2;
   }
 

data/lib/rackup/handler/raptor.rb

@@ -106,6 +106,7 @@ module Rackup
         result[:before_worker_boot] = config.fetch(:before_worker_boot, cli_defaults[:before_worker_boot])
         result[:before_worker_shutdown] = config.fetch(:before_worker_shutdown, cli_defaults[:before_worker_shutdown])
         result[:before_refork] = config.fetch(:before_refork, cli_defaults[:before_refork])
+        result[:plugins] = config.fetch(:plugins, cli_defaults[:plugins])
         result[:stats_file] = config.fetch(:stats_file, cli_defaults[:stats_file])
         result[:control_url] = config[:control_url] if config.key?(:control_url)
         result[:pid_file] = config[:pid_file] if config.key?(:pid_file)
@@ -113,7 +114,7 @@ module Rackup
         result[:stderr_file] = config[:stderr_file] if config.key?(:stderr_file)
         result[:access_log_file] = config[:access_log_file] if config.key?(:access_log_file)
         result[:on_error] = config[:on_error] if config.key?(:on_error)
-        result
+        config.merge(result)
       end
       private_class_method :build_cluster_options
     end

data/lib/raptor/cli.rb

@@ -70,6 +70,7 @@ module Raptor
       before_worker_boot: [].freeze,
       before_worker_shutdown: [].freeze,
       before_refork: [].freeze,
+      plugins: [].freeze,
       stats_file: "tmp/raptor.json",
       control_url: nil,
       pid_file: nil,

data/lib/raptor/cluster.rb

@@ -14,6 +14,7 @@ require_relative "control_server"
 require_relative "http1"
 require_relative "http2"
 require_relative "log"
+require_relative "plugin"
 require_relative "raptor_native"
 require_relative "reactor"
 require_relative "reuseport_bpf"
@@ -126,6 +127,12 @@ module Raptor
     # @rbs @resp_r: IO?
     # @rbs @resp_w: IO?
     # @rbs @bpf_active: bool
+    # @rbs @plugins: Array[Plugin]
+
+    # Returns the cluster configuration available to plugins.
+    #
+    # @return [Hash{Symbol => untyped}]
+    attr_reader :options #: Hash[Symbol, untyped]
 
     # Creates a new Cluster with the given options.
     #
@@ -155,6 +162,7 @@ module Raptor
     # @option options [Array<Proc>] :before_worker_boot procs called with the worker index before it begins serving
     # @option options [Array<Proc>] :before_worker_shutdown procs called with the worker index before its graceful shutdown
     # @option options [Array<Proc>] :before_refork procs called in a worker before it transitions to a seed
+    # @option options [Array<String, Symbol>] :plugins plugins to load and start in order
     # @option options [String, nil] :stats_file path to write per-worker stats JSON, or nil to disable
     # @option options [String, nil] :control_url `unix://` URL serving cluster stats, or nil to disable
     # @option options [String, nil] :pid_file path to write the master PID to, or nil to disable
@@ -168,6 +176,8 @@ module Raptor
     #
     # @rbs (Hash[Symbol, untyped] options) -> void
     def initialize(options)
+      @options = options = options.dup
+      @plugins = []
       @drain_accept_queue = options[:drain_accept_queue]
       @worker_count = options[:workers]
       @http1_ractor_count = options[:http1][:ractors] || self.class.default_http1_ractor_count(@worker_count)
@@ -185,10 +195,10 @@ module Raptor
       @worker_timeout = options[:worker_timeout]
       @worker_drain_timeout = options[:worker_drain_timeout]
       @worker_shutdown_timeout = options[:worker_shutdown_timeout]
-      @before_fork = Array(options[:before_fork])
-      @before_worker_boot = Array(options[:before_worker_boot])
-      @before_worker_shutdown = Array(options[:before_worker_shutdown])
-      @before_refork = Array(options[:before_refork])
+      @before_fork = options[:before_fork] = Array(options[:before_fork]).dup
+      @before_worker_boot = options[:before_worker_boot] = Array(options[:before_worker_boot]).dup
+      @before_worker_shutdown = options[:before_worker_shutdown] = Array(options[:before_worker_shutdown]).dup
+      @before_refork = options[:before_refork] = Array(options[:before_refork]).dup
       @stats_file = options[:stats_file]
       @control_server = ControlServer.new(options[:control_url]) { stats_hash } if options[:control_url]
       @pid_file = options[:pid_file]
@@ -265,40 +275,61 @@ module Raptor
 
       @bpf_active = ReuseportBPF.setup(@worker_count, @binder.listeners.grep(TCPServer))
 
-      @control_server&.bind
-      @worker_count.times { |index| spawn_worker(index) }
-      @control_server&.start
-
-      stats_file_thread = if @stats_file
-        Thread.new do
-          Thread.current.name = "Stats File Writer"
-
-          write_stats_file_loop
+      begin
+        Array(@options[:plugins]).each do |name|
+          plugin = Plugin.load(name)
+          @plugins << plugin
+          plugin.start(self)
         end
-      end
 
-      Systemd.notify("READY=1\nMAINPID=#{Process.pid}")
+        @control_server&.bind
+        @worker_count.times { |index| spawn_worker(index) }
+        @control_server&.start
 
-      until @shutdown
-        break if reap_workers == :no_children
+        stats_file_thread = if @stats_file
+          Thread.new do
+            Thread.current.name = "Stats File Writer"
 
-        perform_hot_restart if @hot_restart_requested
-        poll_seed_ready if @seed_pid && !@seed_ready
-        perform_phased_restart if @phased_restart_requested && !@phased_restarting
-        check_refork_trigger if @refork_thresholds.any? && !@phased_restarting
-        timeout_hung_workers
+            write_stats_file_loop
+          end
+        end
 
-        sleep 0.1
-      end
+        ready = false
+
+        until @shutdown
+          break if reap_workers == :no_children
+
+          perform_hot_restart if @hot_restart_requested
+          poll_seed_ready if @seed_pid && !@seed_ready
+          perform_phased_restart if @phased_restart_requested && !@phased_restarting
+          check_refork_trigger if @refork_thresholds.any? && !@phased_restarting
+          timeout_hung_workers
+
+          unless ready || @shutdown
+            stats = @stats.all
+            if @workers.size == @worker_count && @workers.all? { |index, pid|
+              stat = stats[index]
+              stat[:pid] == pid && stat[:phase] == @phase && stat[:booted] && !@timed_out.include?(pid)
+            }
+              Systemd.notify("READY=1\nMAINPID=#{Process.pid}")
+              ready = true
+            end
+          end
 
-      Systemd.notify("STOPPING=1")
-      stop_workers
-      stats_file_thread&.join
-      @control_server&.shutdown
-      File.delete(@stats_file) rescue nil if @stats_file
-      File.delete(@pid_file) rescue nil if @pid_file
-      @stats.unmap
-      @binder.close
+          sleep 0.1
+        end
+      ensure
+        @shutdown = true
+        Systemd.notify("STOPPING=1")
+        stop_workers
+        stats_file_thread&.join
+        stop_plugins
+        @control_server&.shutdown
+        File.delete(@stats_file) rescue nil if @stats_file
+        File.delete(@pid_file) rescue nil if @pid_file
+        @stats.unmap
+        @binder.close
+      end
     end
 
     # Returns stats for all worker processes.
@@ -312,11 +343,9 @@ module Raptor
       @stats.all
     end
 
-    private
-
-    # Returns cluster statistics for the control server. For an adaptive
-    # pool, `max_threads` is the number of threads currently running so
-    # utilization reflects the capacity available at that moment.
+    # Returns cluster statistics for plugins and the control server.
+    # For an adaptive pool, `max_threads` is the number of threads currently
+    # running so utilization reflects the capacity available at that moment.
     #
     # @return [Hash] cluster statistics
     #
@@ -358,6 +387,22 @@ module Raptor
       }
     end
 
+    private
+
+    # Stops plugins in reverse startup order.
+    #
+    # @rbs () -> void
+    def stop_plugins
+      until @plugins.empty?
+        plugin = @plugins.pop
+        begin
+          plugin.shutdown
+        rescue StandardError => error
+          Log.rescued_error(error)
+        end
+      end
+    end
+
     # @rbs (Numeric time) -> String
     def timestamp(time)
       Time.at(time).utc.iso8601(6)
@@ -767,6 +812,7 @@ module Raptor
       Systemd.notify("RELOADING=1\nMONOTONIC_USEC=#{monotonic_usec}")
       @shutdown = true
       stop_workers
+      stop_plugins
       @binder.clear_close_on_exec
       ENV[INHERITED_FDS_ENV] = JSON.generate(@binder.inheritable_fds)
       @control_server&.shutdown
@@ -819,6 +865,8 @@ module Raptor
         booted: false
       )
 
+      @before_worker_boot.each { |hook| hook.parameters.empty? ? hook.call : hook.call(index) }
+
       reactor = nil
 
       counting_app = ->(env) {
@@ -902,8 +950,6 @@ module Raptor
       )
       server_thread = server.run
 
-      @before_worker_boot.each { |hook| hook.parameters.empty? ? hook.call : hook.call(index) }
-
       Log.info "Worker #{index} booted"
 
       stats_thread = Thread.new do

data/lib/raptor/control_server.rb

@@ -71,6 +71,8 @@ module Raptor
     #
     # @rbs () -> void
     def shutdown
+      return unless @server
+
       client = nil
       @client.swap do |current|
         client = current

data/lib/raptor/http.rb

@@ -16,7 +16,6 @@ module Raptor
 
     CONTENT_LENGTH = "CONTENT_LENGTH"
     CONTENT_TYPE = "CONTENT_TYPE"
-    HTTP_VERSION = "HTTP_VERSION"
     REMOTE_ADDR = "REMOTE_ADDR"
     REQUEST_URI = "REQUEST_URI"
     SERVER_SOFTWARE = "SERVER_SOFTWARE"