raptor 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02fe742ea31e44d742de9f0ed5b94cc53901d39e25b054fe0bd4affd14e169c1
-  data.tar.gz: 4279672bfd532f9bcadfb5ce81d85b8ba4921b8072e302bfc33bf74ce4609224
+  metadata.gz: fbd24155ed44e8b8faf1f5b11a6078a34ab58bf43c290f3ffcf2a4a582c74d16
+  data.tar.gz: 7d6a0f38240c4ae3e723650fcd7a9888f2b59b69f3145018a918524565324972
 SHA512:
-  metadata.gz: 283c078528cfd9cdfdfb795e4587a60607fa382d09efe1194330d5a9a6c7f319af94bc63a2da62396c7aba8484a0041260fcd70b0d82a5c324c7fd6b9221abc5
-  data.tar.gz: 9ee16f87805c340d17da270a81131f191b09500cbd622e3bd06bd32acff3f2ec215004e110187de1d01f6815fdcdfdf962c50c521398ce45e469358d3c155dd8
+  metadata.gz: 811414a1f6a2469ef38c20935564ba204efdc5988437be5d0fa8a167d85a42204abe2a743115d090b24cf2cc8489e8dffdf57a93c1313936dcfa04a7d2213768
+  data.tar.gz: 29a62a959b22ca99c55eea39919d8fe3618fdb5061054718c38503c658c803d77a3a2b40cc9b8089da917faf4041569545073c24c468f6e8552f0d113ee0d469

data/.buildkite/pipeline.yml

@@ -41,7 +41,7 @@ steps:
         soft_fail: true
         image: "rubylang/ruby:master-dev"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci
@@ -52,7 +52,7 @@ steps:
         env:
           RUBY_YJIT_ENABLE: "1"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci
@@ -63,7 +63,7 @@ steps:
         env:
           RUBY_GC_STRESS: "1"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci
@@ -75,7 +75,7 @@ steps:
           RUBY_YJIT_ENABLE: "1"
           RUBY_GC_STRESS: "1"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci

data/CHANGELOG.md

@@ -1,10 +1,22 @@
 ## [Unreleased]
 
+## [0.17.0] - 2026-08-29
+
+- Reserve BPF-routed connections before accept
+- Skip unnecessary HTTP/1.1 response work
+- Assemble HTTP/2 response headers in C
+- Emit HTTP/1.1 response headers and chunked bodies in C
+- Decode chunked request bodies in C
+
+## [0.16.1] - 2026-08-23
+
+- Drop the stale `Ractors=NUM` option from the Rackup handler
+
 ## [0.16.0] - 2026-08-22
 
 - Parse HTTP/2 requests in a dedicated ractor pool
 - Parse the first HTTP/2 frame batch inline on accept
-- Nest the `ractors` config under `http1` and `http2`, defaulting both to `round(cores / workers)` clamped to 1..3 for HTTP/1.1 and 1..2 for HTTP/2
+- Nest the `ractors` config under `http1` and `http2`
 
 ## [0.15.1] - 2026-08-16
 

data/Dockerfile

@@ -18,8 +18,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && rm -rf /var/lib/apt/lists/*
 
 COPY --from=hey-builder /go/bin/hey /usr/local/bin/hey
-COPY --from=hey-builder /usr/local/go /usr/local/go
-ENV PATH=/usr/local/go/bin:${PATH}
 
 ENV BUNDLE_PATH=/workspace/.bundle
 ENV BUNDLE_APP_CONFIG=/workspace/.bundle

data/README.md

@@ -37,7 +37,7 @@ run proc { |_env| [200, { "content-type" => "text/plain" }, ["Hello, World!"]] }
 ```
 > bundle exec raptor -w 10 -t 3 hello_world.ru
 [Raptor 83654|Main|Main] Cluster initializing:
-[Raptor 83654|Main|Main] ├─ Version: 0.16.0
+[Raptor 83654|Main|Main] ├─ Version: 0.17.0
 [Raptor 83654|Main|Main] ├─ Ruby Version: ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
 [Raptor 83654|Main|Main] ├─ Environment: development
 [Raptor 83654|Main|Main] ├─ Master PID: 83654
@@ -201,28 +201,28 @@ Worker 1 (phase 0): pid=91351, requests=1199, busy=1/3, backlog=0, booted, last_
 
 ## (Micro) Benchmarks
 
-Raptor 0.16.0 vs Puma 8.0.2 vs PumaPlus 0.1.0 vs Falcon 0.57.0 across two workload profiles. **IO-bound** is a GET
-endpoint that interleaves 5-10 short sleeps (total 2.5-15ms) with small CPU work, simulating a read path that makes
-several DB or cache calls. **CPU-bound** is a POST endpoint that accepts a small JSON body, interleaves 3-5 chunks of
-JSON item building (total 450-1500 items) with sub-100µs sleeps, and returns the built array, simulating a write path
-that does most of its work in Ruby with a few near-zero-cost cache hits.
+Raptor 0.17.0 vs Puma 8.0.2 vs Falcon 0.57.0 across two workload profiles. **IO-bound** is a GET endpoint that
+interleaves 5-10 short sleeps (total 2.5-15ms) with small CPU work, simulating a read path that makes several DB or
+cache calls. **CPU-bound** is a POST endpoint that accepts a small JSON body, interleaves 3-5 chunks of JSON item
+building (total 450-1500 items) with sub-100µs sleeps, and returns the built array, simulating a write path that does
+most of its work in Ruby with a few near-zero-cost cache hits.
 
 Each cell reports the median throughput and median p95 latency independently across 5 runs, so the two numbers in a row
 may come from different runs. Every run starts a fresh server process so the samples are independent of each other;
 state accumulated in a previous run cannot bias the next. Across the whole table, the widest spread
-((max - min) / 2 / median) between runs of a single cell was ±24.8% for throughput and ±40.3% for p95.
+((max - min) / 2 / median) between runs of a single cell was ±22.4% for throughput and ±37.4% for p95.
 
-| Protocol              | Workload | Raptor req/s | Raptor p95 | Puma req/s  | Puma p95  | vs Puma req/s | vs Puma p95  | PumaPlus req/s | PumaPlus p95 | vs PumaPlus req/s | vs PumaPlus p95 | Falcon req/s | Falcon p95 | vs Falcon req/s | vs Falcon p95 |
-| --------------------- | -------- | ------------ | ---------- | ----------- | --------- | ------------- | ------------ | -------------- | ------------ | ----------------- | --------------- | ------------ | ---------- | --------------- | ------------- |
-| HTTP/1.1              | IO       | 3.21k req/s  | 63.20 ms   | 1.48k req/s | 131.00 ms | 117.7% higher | 51.8% lower  | 1.63k req/s    | 84.20 ms     | 97.0% higher      | 24.9% lower     | 12.27k req/s | 14.00 ms   | 73.8% lower     | 351.4% higher |
-| HTTP/1.1              | CPU      | 8.29k req/s  | 33.30 ms   | 8.56k req/s | 21.20 ms  | 3.2% lower    | 57.1% higher | 8.08k req/s    | 19.20 ms     | 2.6% higher       | 73.4% higher    | 6.62k req/s  | 27.00 ms   | 25.2% higher    | 23.3% higher  |
-| HTTP/1.1 (keep-alive) | IO       | 2.43k req/s  | 54.40 ms   | 1.44k req/s | 110.20 ms | 68.7% higher  | 50.6% lower  | 1.58k req/s    | 87.10 ms     | 54.2% higher      | 37.5% lower     | 6.28k req/s  | 27.90 ms   | 61.3% lower     | 95.0% higher  |
-| HTTP/1.1 (keep-alive) | CPU      | 8.40k req/s  | 18.80 ms   | 8.49k req/s | 21.90 ms  | 1.1% lower    | 14.2% lower  | 8.36k req/s    | 18.40 ms     | 0.4% higher       | 2.2% higher     | 7.09k req/s  | 31.50 ms   | 18.5% higher    | 40.3% lower   |
-| HTTP/2                | IO       | 0.97k req/s  | 197.97 ms  | N/A         | N/A       | -             | -            | 1.52k req/s    | 90.13 ms     | 36.0% lower       | 119.6% higher   | 6.59k req/s  | 27.21 ms   | 85.2% lower     | 627.6% higher |
-| HTTP/2                | CPU      | 6.61k req/s  | 31.98 ms   | N/A         | N/A       | -             | -            | 8.05k req/s    | 19.23 ms     | 17.9% lower       | 66.3% higher    | 8.09k req/s  | 45.04 ms   | 18.3% lower     | 29.0% lower   |
+| Protocol              | Workload | Raptor req/s | Raptor p95 | Puma req/s  | Puma p95  | vs Puma req/s | vs Puma p95  | Falcon req/s | Falcon p95 | vs Falcon req/s | vs Falcon p95 |
+| --------------------- | -------- | ------------ | ---------- | ----------- | --------- | ------------- | ------------ | ------------ | ---------- | --------------- | ------------- |
+| HTTP/1.1              | IO       | 3.35k req/s  | 59.60 ms   | 1.51k req/s | 126.70 ms | 121.9% higher | 53.0% lower  | 12.19k req/s | 14.10 ms   | 72.6% lower     | 322.7% higher |
+| HTTP/1.1              | CPU      | 8.31k req/s  | 25.00 ms   | 8.63k req/s | 21.10 ms  | 3.7% lower    | 18.5% higher | 6.57k req/s  | 27.40 ms   | 26.4% higher    | 8.8% lower    |
+| HTTP/1.1 (keep-alive) | IO       | 3.22k req/s  | 46.90 ms   | 1.47k req/s | 113.80 ms | 119.9% higher | 58.8% lower  | 6.23k req/s  | 28.20 ms   | 48.2% lower     | 66.3% higher  |
+| HTTP/1.1 (keep-alive) | CPU      | 8.30k req/s  | 23.30 ms   | 8.41k req/s | 22.10 ms  | 1.3% lower    | 5.4% higher  | 6.95k req/s  | 32.30 ms   | 19.5% higher    | 27.9% lower   |
+| HTTP/2                | IO       | 0.98k req/s  | 196.28 ms  | N/A         | N/A       | -             | -            | 6.55k req/s  | 27.71 ms   | 85.1% lower     | 608.4% higher |
+| HTTP/2                | CPU      | 6.23k req/s  | 33.11 ms   | N/A         | N/A       | -             | -            | 6.92k req/s  | 42.94 ms   | 10.0% lower     | 22.9% lower   |
 
 > ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [aarch64-linux]
-> 10 worker processes; Raptor, Puma, and PumaPlus run 3 threads per worker, Falcon runs unbounded fibers per worker;
+> 10 worker processes; Raptor and Puma run 3 threads per worker, Falcon runs unbounded fibers per worker;
 > 120 concurrent HTTP/1.1 client connections; 40 concurrent HTTP/2 client connections × 3 streams each
 
 See [bin/benchmark](bin/benchmark) for more details.

data/docs/brisrails-talk.md

@@ -37,7 +37,7 @@ _[luma.com/t3l24s8h](https://luma.com/t3l24s8h)_
 - <big>I built a Ruby web server over the last few months</big>
 - <big>It's called Raptor</big>
 - <big>It runs Rack apps, like Puma and Falcon do</big>
-- <big>It's built around Ruby 4's Ractors</big>
+- <big>It's built around a Ractor-parallel HTTP parser</big>
 - <big>It's fast enough that the numbers are interesting</big>
 - <big>It's not production-ready. Nobody's Rails app should be behind it yet.</big>
 

data/docs/raptor-vs-puma.md

@@ -1,6 +1,6 @@
 # Raptor vs Puma: A Design Comparison
 
-Raptor is a Ruby web server designed around Ruby 4's Ractors. On CPU-bound HTTP/1.1 it holds a real edge over the latest Puma release on the same hardware regardless of keep-alive; on IO-heavy work fibers still win, and Falcon is the server to compare to there rather than Raptor or Puma. Raptor also speaks HTTP/2 natively, which Puma does not. This document is a systems-design walkthrough of how it manages both.
+Raptor is a Ruby web server designed around a Ractor-parallel HTTP parser. On CPU-bound HTTP/1.1 it holds a real edge over the latest Puma release on the same hardware regardless of keep-alive; on IO-heavy work fibers still win, and Falcon is the server to compare to there rather than Raptor or Puma. Raptor also speaks HTTP/2 natively, which Puma does not. This document is a systems-design walkthrough of how it manages both.
 
 ## Why this document exists
 
@@ -20,7 +20,7 @@ This document focuses on Puma because Puma is the incumbent that any new Ruby we
 
 Raptor is a research project. It hasn't run production traffic. The numbers in the README come from a repeatable microbenchmark, not from a real deployment. The benchmark measures only the **server** work: accepting connections, parsing, dispatching, and writing responses. It does not measure your application. In a typical Rails app where most of a request's time goes to ActiveRecord and downstream services, the server accounts for maybe 5 to 15 percent of the total, so a +N% number in this table will show up as a much smaller improvement in production. The gap is real, but it isn't what a Rails app against a real database will report.
 
-The Raptor README carries the [current head-to-head numbers](../README.md#micro-benchmarks) against the latest Puma and Falcon releases, run on the same hardware with the same Rack app on a recent Ruby with YJIT enabled. All servers run one worker process per available CPU; Raptor, Puma, and PumaPlus use three threads per worker, and Falcon uses unbounded fibers per worker. Load generators use four client connections per app thread, so on the 10-core machine that produced the current numbers that's 120 concurrent HTTP/1.1 client connections and 40 h2 connections × 3 streams each.
+The Raptor README carries the [current head-to-head numbers](../README.md#micro-benchmarks) against the latest Puma and Falcon releases, run on the same hardware with the same Rack app on a recent Ruby with YJIT enabled. All servers run one worker process per available CPU; Raptor and Puma use three threads per worker, and Falcon uses unbounded fibers per worker. Load generators use four client connections per app thread, so on the 10-core machine that produced the current numbers that's 120 concurrent HTTP/1.1 client connections and 40 h2 connections × 3 streams each.
 
 Two workload profiles are measured. **IO-bound** is a GET endpoint that does 5 to 10 short sleeps interleaved with small CPU work per request, simulating a read path that makes several DB or cache calls throughout its lifetime. **CPU-bound** is a POST endpoint with a small JSON body that builds a JSON response in 3 to 5 chunks interleaved with sub-100µs sleeps, simulating a write path that does most of its work in Ruby with a few near-zero-cost cache hits. The workloads are interleaved rather than a single bulk sleep or single bulk serialise so a fiber-per-connection server like Falcon doesn't look artificially good from one-shot IO, and the CPU-bound workload is heavily CPU-dominated by design (roughly 95% CPU / 5% IO by wall time) so it actually measures CPU work rather than smuggling in enough IO for fibers to multiplex.
 

data/ext/raptor_bpf/reuseport_select.bpf.c

@@ -2,7 +2,6 @@
 #include <bpf/bpf_helpers.h>
 
 #define MAX_WORKERS 64
-#define LOAD_TIE_TOLERANCE 1
 
 // Per-worker listening sockets, keyed by worker index.
 struct {
@@ -20,14 +19,12 @@ struct {
   __uint(max_entries, MAX_WORKERS + 1);
 } loads SEC(".maps");
 
-// Routes each incoming connection to the least-loaded worker. When the
-// spread between the busiest and idlest worker is within
-// `LOAD_TIE_TOLERANCE`, all workers are treated as tied and the connection
-// is placed by 4-tuple hash so bursts of accepts spread across workers
-// instead of clustering on whichever worker most recently reported the
-// lowest load.
+// Uses the power-of-two-choices strategy and reserves the selected worker's
+// slot before returning. Sampling two hash-selected workers avoids
+// concentrating variable-cost requests, while the reservation prevents a
+// burst from repeatedly selecting the same reported load.
 SEC("sk_reuseport")
-int select_least_loaded(struct sk_reuseport_md *ctx) {
+int select_less_loaded(struct sk_reuseport_md *ctx) {
   __u32 count_key = 0;
   __u32 *count_ptr = bpf_map_lookup_elem(&loads, &count_key);
   if (!count_ptr || *count_ptr == 0) {
@@ -38,29 +35,23 @@ int select_least_loaded(struct sk_reuseport_md *ctx) {
     num_workers = MAX_WORKERS;
   }
 
-  __u32 min_load = ~0u;
-  __u32 max_load = 0;
-  __u32 min_idx = 0;
-
-  for (__u32 worker_idx = 0; worker_idx < MAX_WORKERS; worker_idx++) {
-    if (worker_idx >= num_workers) {
-      break;
-    }
-    __u32 worker_key = worker_idx + 1;
-    __u32 *load_ptr = bpf_map_lookup_elem(&loads, &worker_key);
-    if (!load_ptr) {
-      continue;
-    }
-    if (*load_ptr < min_load) {
-      min_load = *load_ptr;
-      min_idx = worker_idx;
-    }
-    if (*load_ptr > max_load) {
-      max_load = *load_ptr;
+  __u32 chosen_idx = ctx->hash % num_workers;
+  __u32 chosen_key = chosen_idx + 1;
+  __u32 *chosen_load = bpf_map_lookup_elem(&loads, &chosen_key);
+  if (num_workers > 1) {
+    __u32 alternate_idx = (chosen_idx + 1 + ((ctx->hash >> 16) % (num_workers - 1))) % num_workers;
+    __u32 alternate_key = alternate_idx + 1;
+    __u32 *alternate_load = bpf_map_lookup_elem(&loads, &alternate_key);
+    if (chosen_load && alternate_load && *alternate_load < *chosen_load) {
+      chosen_idx = alternate_idx;
+      chosen_load = alternate_load;
     }
   }
 
-  __u32 chosen_idx = (max_load - min_load <= LOAD_TIE_TOLERANCE) ? (ctx->hash % num_workers) : min_idx;
+  if (chosen_load) {
+    __sync_fetch_and_add(chosen_load, 1);
+  }
+
   bpf_sk_select_reuseport(ctx, &socks, &chosen_idx, 0);
   return SK_PASS;
 }

data/ext/raptor_http/raptor_http.c

@@ -37,6 +37,8 @@ typedef struct raptor_parser {
 #define FLAG_HAS_BODY 0x2
 #define FLAG_FINISHED 0x4
 
+#define MAX_CHUNK_OVERHEAD (16 * 1024)
+
 static VALUE eHttpParserError;
 static VALUE global_request_method;
 static VALUE global_request_uri;
@@ -44,6 +46,10 @@ static VALUE global_query_string;
 static VALUE global_server_protocol;
 static VALUE global_request_path;
 static VALUE global_fragment;
+static ID id_complete;
+static ID id_incomplete;
+static ID id_malformed;
+static ID id_too_large;
 
 struct common_field {
   const char *name;
@@ -1316,6 +1322,200 @@ static VALUE parser_body(VALUE self) {
   return parser->body;
 }
 
+static const char *find_crlf(const char *buf, size_t len) {
+  if (len < 2) return NULL;
+  const char *end = buf + len - 1;
+  for (const char *p = buf; p < end; p++) {
+    if (*p == '\r' && *(p + 1) == '\n') return p;
+  }
+  return NULL;
+}
+
+static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
+  (void)self;
+  VALUE buffer, max_size;
+  rb_scan_args(argc, argv, "11", &buffer, &max_size);
+  Check_Type(buffer, T_STRING);
+
+  const char *buf = RSTRING_PTR(buffer);
+  size_t len = (size_t)RSTRING_LEN(buffer);
+  size_t offset = 0;
+  size_t overhead = 0;
+  int has_max = !NIL_P(max_size);
+  size_t max_bytes = has_max ? NUM2SIZET(max_size) : 0;
+
+  VALUE decoded = rb_str_buf_new((long)len);
+
+  while (offset < len) {
+    const char *crlf = find_crlf(buf + offset, len - offset);
+    if (!crlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+
+    size_t line_len = (size_t)(crlf - (buf + offset));
+    size_t size_len = line_len;
+    for (size_t i = 0; i < line_len; i++) {
+      if (buf[offset + i] == ';') { size_len = i; break; }
+    }
+    if (size_len == 0) return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+
+    uint64_t chunk_size = 0;
+    for (size_t i = 0; i < size_len; i++) {
+      char c = buf[offset + i];
+      uint64_t digit;
+      if (c >= '0' && c <= '9') digit = (uint64_t)(c - '0');
+      else if (c >= 'a' && c <= 'f') digit = (uint64_t)(c - 'a' + 10);
+      else if (c >= 'A' && c <= 'F') digit = (uint64_t)(c - 'A' + 10);
+      else return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+      if (chunk_size > (UINT64_MAX >> 4)) return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+      chunk_size = (chunk_size << 4) | digit;
+    }
+    if (chunk_size > (uint64_t)(SIZE_MAX / 2)) return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+
+    size_t crlf_offset = offset + line_len;
+
+    if (chunk_size == 0) {
+      size_t trailer_offset = crlf_offset + 2;
+      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);
+        if (!tcrlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+        if (tcrlf == buf + trailer_offset) return rb_ary_new_from_args(2, decoded, ID2SYM(id_complete));
+        trailer_offset = (size_t)(tcrlf - buf) + 2;
+      }
+    }
+
+    size_t decoded_len = (size_t)RSTRING_LEN(decoded);
+    if (has_max && (decoded_len + (size_t)chunk_size) > max_bytes) {
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_too_large));
+    }
+
+    overhead += line_len + 4;
+    if (overhead > (decoded_len + (size_t)chunk_size + MAX_CHUNK_OVERHEAD)) {
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+    }
+
+    size_t data_offset = crlf_offset + 2;
+    size_t available = len > data_offset ? len - data_offset : 0;
+    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);
+
+    offset = data_offset + (size_t)chunk_size + 2;
+  }
+
+  return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+}
+
+static uint8_t illegal_header_key_bitmap[32];
+static uint8_t illegal_header_value_bitmap[32];
+
+static void bitmap_set(uint8_t *bitmap, unsigned char byte) {
+  bitmap[byte >> 3] |= (uint8_t)(1u << (byte & 7));
+}
+
+static int contains_illegal_byte(const uint8_t *bitmap, const char *str, size_t len) {
+  for (size_t i = 0; i < len; i++) {
+    unsigned char byte = (unsigned char)str[i];
+    if ((bitmap[byte >> 3] >> (byte & 7)) & 1) return 1;
+  }
+  return 0;
+}
+
+static VALUE parser_illegal_header_key_p(VALUE self, VALUE key) {
+  (void)self;
+  Check_Type(key, T_STRING);
+  return contains_illegal_byte(illegal_header_key_bitmap, RSTRING_PTR(key), (size_t)RSTRING_LEN(key)) ? Qtrue : Qfalse;
+}
+
+static VALUE parser_illegal_header_value_p(VALUE self, VALUE value) {
+  (void)self;
+  Check_Type(value, T_STRING);
+  return contains_illegal_byte(illegal_header_value_bitmap, RSTRING_PTR(value), (size_t)RSTRING_LEN(value)) ? Qtrue : Qfalse;
+}
+
+static void emit_header_line(VALUE buffer, const char *name, long name_len,
+                             const char *value, long value_len) {
+  if (value_len == 0) return;
+  if (contains_illegal_byte(illegal_header_value_bitmap, value, (size_t)value_len)) return;
+  rb_str_cat(buffer, name, name_len);
+  rb_str_cat(buffer, ": ", 2);
+  rb_str_cat(buffer, value, value_len);
+  rb_str_cat(buffer, "\r\n", 2);
+}
+
+static void emit_header(VALUE buffer, const char *name, long name_len, VALUE value) {
+  VALUE str = RB_TYPE_P(value, T_STRING) ? value : rb_funcall(value, rb_intern("to_s"), 0);
+  const char *ptr = RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+  if (len == 0) return;
+
+  if (!memchr(ptr, '\n', (size_t)len)) {
+    emit_header_line(buffer, name, name_len, ptr, len);
+    return;
+  }
+
+  long line_start = 0;
+  for (long i = 0; i < len; i++) {
+    if (ptr[i] == '\n') {
+      emit_header_line(buffer, name, name_len, ptr + line_start, i - line_start);
+      line_start = i + 1;
+    }
+  }
+  if (line_start < len) {
+    emit_header_line(buffer, name, name_len, ptr + line_start, len - line_start);
+  }
+}
+
+static int format_header_iter(VALUE key, VALUE value, VALUE data) {
+  VALUE buffer = (VALUE)data;
+  if (!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+  const char *name = RSTRING_PTR(key);
+  long name_len = RSTRING_LEN(key);
+  if (contains_illegal_byte(illegal_header_key_bitmap, name, (size_t)name_len)) return ST_CONTINUE;
+
+  if (RB_TYPE_P(value, T_ARRAY)) {
+    long entries = RARRAY_LEN(value);
+    for (long i = 0; i < entries; i++) {
+      emit_header(buffer, name, name_len, RARRAY_AREF(value, i));
+    }
+  } else {
+    emit_header(buffer, name, name_len, value);
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE parser_format_headers(VALUE self, VALUE buffer, VALUE headers) {
+  (void)self;
+  Check_Type(buffer, T_STRING);
+  Check_Type(headers, T_HASH);
+  rb_hash_foreach(headers, format_header_iter, buffer);
+  return buffer;
+}
+
+static VALUE parser_chunked_encode(VALUE self, VALUE buffer, VALUE chunk) {
+  (void)self;
+  Check_Type(buffer, T_STRING);
+  Check_Type(chunk, T_STRING);
+  long chunk_len = RSTRING_LEN(chunk);
+  if (chunk_len == 0) return buffer;
+
+  char hex_buf[17];
+  int hex_len = snprintf(hex_buf, sizeof(hex_buf), "%lx", (unsigned long)chunk_len);
+  rb_str_cat(buffer, hex_buf, hex_len);
+  rb_str_cat(buffer, "\r\n", 2);
+  rb_str_cat(buffer, RSTRING_PTR(chunk), chunk_len);
+  rb_str_cat(buffer, "\r\n", 2);
+  return buffer;
+}
+
+static void init_illegal_header_bitmaps(void) {
+  for (int byte = 0x00; byte <= 0x20; byte++) bitmap_set(illegal_header_key_bitmap, (unsigned char)byte);
+  const char *key_specials = "()<>@,;:\\\"/[]?={}";
+  for (const char *p = key_specials; *p; p++) bitmap_set(illegal_header_key_bitmap, (unsigned char)*p);
+  bitmap_set(illegal_header_key_bitmap, 0x7F);
+
+  for (int byte = 0x00; byte <= 0x08; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
+  for (int byte = 0x0A; byte <= 0x1F; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
+}
+
 RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   rb_ext_ractor_safe(true);
 
@@ -1337,6 +1537,13 @@ RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   global_request_path = rb_str_new2("PATH_INFO");
   global_fragment = rb_str_new2("FRAGMENT");
 
+  id_complete = rb_intern("complete");
+  id_incomplete = rb_intern("incomplete");
+  id_malformed = rb_intern("malformed");
+  id_too_large = rb_intern("too_large");
+
+  init_illegal_header_bitmaps();
+
   for (size_t i = 0; i < NUM_COMMON_FIELDS; i++) {
     common_fields[i].interned = rb_enc_interned_str(common_fields[i].name, common_fields[i].len, rb_utf8_encoding());
     rb_global_variable(&common_fields[i].interned);
@@ -1351,4 +1558,10 @@ RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   rb_define_method(cHttpParser, "nread", parser_nread, 0);
   rb_define_method(cHttpParser, "reset", parser_reset, 0);
   rb_define_method(cHttpParser, "body", parser_body, 0);
+  rb_define_singleton_method(cHttpParser, "decode_chunked", parser_decode_chunked, -1);
+  rb_define_singleton_method(cHttpParser, "illegal_header_key?", parser_illegal_header_key_p, 1);
+  rb_define_singleton_method(cHttpParser, "illegal_header_value?", parser_illegal_header_value_p, 1);
+  rb_define_singleton_method(cHttpParser, "format_headers", parser_format_headers, 2);
+  rb_define_singleton_method(cHttpParser, "chunked_encode", parser_chunked_encode, 2);
+  rb_define_const(cHttpParser, "MAX_CHUNK_OVERHEAD", INT2FIX(MAX_CHUNK_OVERHEAD));
 }

data/ext/raptor_http2/raptor_http2.c

@@ -599,6 +599,65 @@ static VALUE h2_encode_headers(VALUE self, VALUE headers) {
   return hpack_encode_header_block(headers);
 }
 
+static const char *const HOP_BY_HOP_HEADERS[] = {
+  "connection", "transfer-encoding", "keep-alive", "upgrade", "proxy-connection"
+};
+#define NUM_HOP_BY_HOP_HEADERS 5
+
+static int is_hop_by_hop(const char *name, long name_len) {
+  for (size_t i = 0; i < NUM_HOP_BY_HOP_HEADERS; i++) {
+    size_t hbh_len = strlen(HOP_BY_HOP_HEADERS[i]);
+    if ((long)hbh_len == name_len && memcmp(name, HOP_BY_HOP_HEADERS[i], hbh_len) == 0) return 1;
+  }
+  return 0;
+}
+
+static VALUE ascii_lowercase_str(VALUE str) {
+  long len = RSTRING_LEN(str);
+  VALUE lower = rb_str_new(RSTRING_PTR(str), len);
+  char *ptr = RSTRING_PTR(lower);
+  for (long i = 0; i < len; i++) {
+    if (ptr[i] >= 'A' && ptr[i] <= 'Z') ptr[i] = (char)(ptr[i] | 0x20);
+  }
+  return lower;
+}
+
+static int response_headers_iter(VALUE key, VALUE value, VALUE data) {
+  VALUE pairs = data;
+  if (!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+
+  VALUE lowered = ascii_lowercase_str(key);
+  const char *lname = RSTRING_PTR(lowered);
+  long lname_len = RSTRING_LEN(lowered);
+
+  if (lname_len >= 5 && memcmp(lname, "rack.", 5) == 0) return ST_CONTINUE;
+  if (is_hop_by_hop(lname, lname_len)) return ST_CONTINUE;
+
+  if (RB_TYPE_P(value, T_ARRAY)) {
+    long entries = RARRAY_LEN(value);
+    for (long i = 0; i < entries; i++) {
+      VALUE entry = RARRAY_AREF(value, i);
+      VALUE str = RB_TYPE_P(entry, T_STRING) ? entry : rb_obj_as_string(entry);
+      rb_ary_push(pairs, rb_ary_new_from_args(2, lowered, str));
+    }
+  } else {
+    VALUE str = RB_TYPE_P(value, T_STRING) ? value : rb_obj_as_string(value);
+    rb_ary_push(pairs, rb_ary_new_from_args(2, lowered, str));
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE h2_encode_response_headers(VALUE self, VALUE status, VALUE headers) {
+  (void)self;
+  Check_Type(headers, T_HASH);
+
+  VALUE pairs = rb_ary_new();
+  rb_ary_push(pairs, rb_ary_new_from_args(2, rb_str_new_lit(":status"), rb_obj_as_string(status)));
+  rb_hash_foreach(headers, response_headers_iter, pairs);
+
+  return hpack_encode_header_block(pairs);
+}
+
 static VALUE h2_parse_frame(VALUE self, VALUE buffer) {
   (void)self;
   Check_Type(buffer, T_STRING);
@@ -765,6 +824,7 @@ RUBY_FUNC_EXPORTED void Init_raptor_http2(void) {
   rb_define_method(cHttp2Parser, "parse_frame", h2_parse_frame, 1);
   rb_define_method(cHttp2Parser, "parse_headers", h2_parse_headers, 2);
   rb_define_method(cHttp2Parser, "encode_headers", h2_encode_headers, 1);
+  rb_define_method(cHttp2Parser, "encode_response_headers", h2_encode_response_headers, 2);
   rb_define_method(cHttp2Parser, "parse_settings", h2_parse_settings, 1);
   rb_define_method(cHttp2Parser, "build_settings", h2_build_settings, 1);
   rb_define_method(cHttp2Parser, "build_frame", h2_build_frame, 4);

data/lib/rackup/handler/raptor.rb

@@ -43,7 +43,6 @@ module Rackup
           "Host=HOST"   => "Hostname to listen on (default: #{DEFAULT_OPTIONS[:Host]})",
           "Port=PORT"   => "Port to listen on (default: #{DEFAULT_OPTIONS[:Port]})",
           "Workers=NUM" => "Number of worker processes (default: available processor count)",
-          "Ractors=NUM" => "Number of pipeline ractors per worker (default: 1)",
           "Threads=NUM" => "Number of threads per worker (default: 3)",
           "Config=PATH" => "Load additional configuration from PATH"
         }

data/lib/raptor/cluster.rb

@@ -46,11 +46,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(worker_count)
-      cores = Integer(Concurrent.available_processor_count)
+    # @rbs (Integer worker_count, ?cores: Integer) -> Integer
+    def self.default_http1_ractor_count(worker_count, cores: Integer(Concurrent.available_processor_count))
       (cores.to_f / worker_count).round.clamp(1, HTTP1_RACTOR_COUNT_CAP)
     end
 
@@ -60,11 +60,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(worker_count)
-      cores = Integer(Concurrent.available_processor_count)
+    # @rbs (Integer worker_count, ?cores: Integer) -> Integer
+    def self.default_http2_ractor_count(worker_count, cores: Integer(Concurrent.available_processor_count))
       (cores.to_f / worker_count).round.clamp(1, HTTP2_RACTOR_COUNT_CAP)
     end