quicsilver 0.3.0 → 0.5.0

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: quicsilver
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Haroon Ahmed
 bindir: exe
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: cibuildgem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +121,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+- !ruby/object:Gem::Dependency
+  name: protocol-rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -172,6 +228,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- ".github/workflows/cibuildgem.yaml"
 - ".gitignore"
 - ".gitmodules"
 - ".ruby-version"
@@ -181,25 +238,59 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmarks/baseline.rb
+- benchmarks/compare.rb
 - benchmarks/components.rb
-- benchmarks/concurrent.rb
 - benchmarks/helpers.rb
-- benchmarks/quicsilver_server.rb
-- benchmarks/rails.rb
-- benchmarks/throughput.rb
+- benchmarks/latency.rb
+- benchmarks/loss.rb
+- benchmarks/mobile.rb
 - bin/console
 - bin/setup
+- docs/connection_identity.md
 - examples/README.md
+- examples/benchmark.rb
+- examples/connection_pool_demo.rb
+- examples/example_helper.rb
+- examples/falcon_middleware.rb
+- examples/feature_demo.rb
+- examples/grpc_style.rb
+- examples/latency_aware_routing.rb
+- examples/lifecycle_drain.rb
 - examples/minimal_http3_server.rb
+- examples/priorities.rb
+- examples/protocol_http_server.rb
 - examples/rack_http3_server.rb
-- examples/setup_certs.sh
+- examples/rails_feature_test.rb
+- examples/server_stats.rb
 - examples/simple_client_test.rb
+- examples/streaming_sse.rb
+- examples/trailers.rb
+- examples/webtransport_smoke.rb
+- examples/worker_load_balancing.rb
 - ext/quicsilver/extconf.rb
+- ext/quicsilver/include/msquic.h
+- ext/quicsilver/include/msquic_posix.h
+- ext/quicsilver/include/quic_sal_stub.h
+- ext/quicsilver/msquic_patch.rb
+- ext/quicsilver/patches/reliable-reset.patch
+- ext/quicsilver/patches/stream-final-size.patch
 - ext/quicsilver/quicsilver.c
 - lib/quicsilver.rb
 - lib/quicsilver/client/client.rb
+- lib/quicsilver/client/connection_pool.rb
 - lib/quicsilver/client/request.rb
+- lib/quicsilver/errors.rb
+- lib/quicsilver/libmsquic.2.dylib
+- lib/quicsilver/protocol/adapter.rb
+- lib/quicsilver/protocol/capsule.rb
+- lib/quicsilver/protocol/connect_stream_decoder.rb
+- lib/quicsilver/protocol/control_stream_parser.rb
+- lib/quicsilver/protocol/datagram.rb
+- lib/quicsilver/protocol/frame_parser.rb
+- lib/quicsilver/protocol/frame_reader.rb
 - lib/quicsilver/protocol/frames.rb
+- lib/quicsilver/protocol/priority.rb
 - lib/quicsilver/protocol/qpack/decoder.rb
 - lib/quicsilver/protocol/qpack/encoder.rb
 - lib/quicsilver/protocol/qpack/header_block_decoder.rb
@@ -208,21 +299,40 @@ files:
 - lib/quicsilver/protocol/request_parser.rb
 - lib/quicsilver/protocol/response_encoder.rb
 - lib/quicsilver/protocol/response_parser.rb
+- lib/quicsilver/protocol/stream_input.rb
+- lib/quicsilver/protocol/stream_output.rb
+- lib/quicsilver/protocol/unidirectional_stream.rb
+- lib/quicsilver/protocol/web_transport.rb
+- lib/quicsilver/rack/context.rb
+- lib/quicsilver/response.rb
 - lib/quicsilver/server/listener_data.rb
+- lib/quicsilver/server/rack_adapter.rb
+- lib/quicsilver/server/receive_queue.rb
 - lib/quicsilver/server/request_handler.rb
 - lib/quicsilver/server/request_registry.rb
+- lib/quicsilver/server/scheduler.rb
+- lib/quicsilver/server/schedulers/fiber_scheduler.rb
+- lib/quicsilver/server/schedulers/thread_scheduler.rb
 - lib/quicsilver/server/server.rb
+- lib/quicsilver/server/web_transport_flow_control.rb
+- lib/quicsilver/server/web_transport_manager.rb
+- lib/quicsilver/server/web_transport_registry.rb
+- lib/quicsilver/server/web_transport_session.rb
+- lib/quicsilver/server/web_transport_stream.rb
 - lib/quicsilver/transport/configuration.rb
 - lib/quicsilver/transport/connection.rb
+- lib/quicsilver/transport/connection_stats.rb
 - lib/quicsilver/transport/event_loop.rb
 - lib/quicsilver/transport/inbound_stream.rb
 - lib/quicsilver/transport/stream.rb
 - lib/quicsilver/transport/stream_event.rb
+- lib/quicsilver/transport/stream_id.rb
 - lib/quicsilver/version.rb
 - lib/rackup/handler/quicsilver.rb
 - quicsilver.gemspec
 homepage: https://github.com/hahmed/quicsilver
-licenses: []
+licenses:
+- MIT
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/hahmed/quicsilver
@@ -235,14 +345,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: HTTP/3 server implementation for Ruby
 test_files: []

data/benchmarks/concurrent.rb

@@ -1,110 +0,0 @@
-#!/usr/bin/env ruby
-# Concurrency benchmark: tests HTTP/3 multiplexing and multi-connection overhead.
-#
-# Self-contained:
-#   ruby benchmarks/concurrent.rb
-#
-# External server:
-#   HOST=127.0.0.1 PORT=4433 ruby benchmarks/concurrent.rb
-
-require_relative "helpers"
-require "benchmark"
-
-MULTIPLEX_REQUESTS = ENV.fetch("MULTIPLEX_REQUESTS", "50").to_i
-NUM_CLIENTS        = ENV.fetch("NUM_CLIENTS", "20").to_i
-REQUESTS_PER_CLIENT = ENV.fetch("REQUESTS_PER_CLIENT", "5").to_i
-HOST = ENV["HOST"]
-PORT = ENV["PORT"]&.to_i
-
-def test_multiplexing(host, port)
-  Benchmarks::Helpers.print_header(
-    "Test 1: Single-connection multiplexing",
-    requests: MULTIPLEX_REQUESTS
-  )
-
-  request_times = []
-  mutex = Mutex.new
-
-  client = Quicsilver::Client.new(host, port, unsecure: true)
-  client.connect
-
-  elapsed = Benchmark.realtime do
-    threads = MULTIPLEX_REQUESTS.times.map do |i|
-      Thread.new do
-        start = Time.now
-        client.get("/multiplex/#{i}")
-        req_time = Time.now - start
-        mutex.synchronize { request_times << req_time }
-      end
-    end
-    threads.each(&:join)
-  end
-
-  client.disconnect
-
-  concurrency_factor = request_times.any? ? (request_times.sum / elapsed).round(2) : 0
-  puts "  Wall clock:          #{(elapsed * 1000).round(2)}ms"
-  puts "  Avg request time:    #{(request_times.sum / request_times.size * 1000).round(2)}ms"
-  puts "  Throughput:          #{(MULTIPLEX_REQUESTS / elapsed).round(2)} req/s"
-  puts "  Concurrency factor:  #{concurrency_factor}x"
-  Benchmarks::Helpers.print_stats("Latency", request_times)
-end
-
-def test_concurrent_clients(host, port)
-  Benchmarks::Helpers.print_header(
-    "Test 2: Concurrent clients",
-    clients:            NUM_CLIENTS,
-    requests_per_client: REQUESTS_PER_CLIENT
-  )
-
-  request_times = []
-  mutex = Mutex.new
-  successful = 0
-
-  elapsed = Benchmark.realtime do
-    threads = NUM_CLIENTS.times.map do |i|
-      Thread.new do
-        client = Quicsilver::Client.new(host, port, unsecure: true)
-        client.connect
-
-        REQUESTS_PER_CLIENT.times do |req|
-          start = Time.now
-          client.get("/client#{i}/request#{req}")
-          req_time = Time.now - start
-          mutex.synchronize { request_times << req_time }
-        end
-
-        client.disconnect
-        mutex.synchronize { successful += 1 }
-      rescue => e
-        $stderr.puts "  Client #{i} error: #{e.message}"
-      end
-    end
-    threads.each(&:join)
-  end
-
-  total_requests = request_times.size
-  concurrency_factor = request_times.any? ? (request_times.sum / elapsed).round(2) : 0
-
-  puts "  Successful clients:  #{successful}/#{NUM_CLIENTS}"
-  puts "  Total requests:      #{total_requests}"
-  puts "  Wall clock:          #{(elapsed * 1000).round(2)}ms"
-  puts "  Avg request time:    #{request_times.any? ? (request_times.sum / request_times.size * 1000).round(2) : "N/A"}ms"
-  puts "  Throughput:          #{(total_requests / elapsed).round(2)} req/s"
-  puts "  Concurrency factor:  #{concurrency_factor}x"
-  Benchmarks::Helpers.print_stats("Latency", request_times)
-end
-
-def run_all(host, port)
-  test_multiplexing(host, port)
-  test_concurrent_clients(host, port)
-end
-
-if HOST && PORT
-  run_all(HOST, PORT)
-else
-  puts "Booting inline server..."
-  Benchmarks::Helpers.with_server(Benchmarks::Helpers.benchmark_app) do |port|
-    run_all("127.0.0.1", port)
-  end
-end

data/benchmarks/quicsilver_server.rb

@@ -1,46 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "quicsilver"
-require 'localhost/authority'
-require 'json'
-
-SIMPLE_APP = lambda do |env|
-  case env['PATH_INFO']
-  when '/'
-    [200, {'Content-Type' => 'text/plain'}, ['OK']]
-  when '/json'
-    body = JSON.generate({status: 'ok', timestamp: Time.now.to_i})
-    [200, {'Content-Type' => 'application/json'}, [body]]
-  when '/echo'
-    [200, {'Content-Type' => 'text/plain'}, [env['REQUEST_METHOD']]]
-  else
-    [404, {'Content-Type' => 'text/plain'}, ['Not Found']]
-  end
-end
-
-port = ENV["PORT"] || 4433
-default_host = ENV["HOST"] || "0.0.0.0"
-
-authority = Localhost::Authority.fetch
-cert_file = authority.certificate_path
-key_file = authority.key_path
-
-config = ::Quicsilver::Transport::Configuration.new(cert_file, key_file)
-
-server = ::Quicsilver::Server.new(
-  port.to_i,
-  address: default_host,
-  app: SIMPLE_APP,
-  server_configuration: config
-)
-
-puts "Starting Quicsilver on port #{port}..."
-
-trap("INT") do
-  puts "\nStopping server..."
-  server.stop
-  exit
-end
-
-server.start  # Blocks until shutdown

data/benchmarks/rails.rb

@@ -1,170 +0,0 @@
-#!/usr/bin/env ruby
-# Rails benchmark: concurrent POST, GET, DELETE against a Rails app.
-# Multiplexes requests within each connection (HTTP/3 streams),
-# capped by CONCURRENCY to stay within the server's stream limit.
-#
-# Start blogz first:
-#   cd ../blogz && bundle exec rackup -s quicsilver -p 4433
-#
-# Usage:
-#   CONNECTIONS=5 ITERATIONS=100 ruby benchmarks/rails.rb
-#   CONCURRENCY=8 CONNECTIONS=3 ITERATIONS=200 ruby benchmarks/rails.rb
-
-require "bundler/setup"
-require "quicsilver"
-require "json"
-require "benchmark"
-
-require_relative "helpers"
-
-HOST        = ENV.fetch("HOST", "127.0.0.1")
-PORT        = ENV.fetch("PORT", "4433").to_i
-CONNECTIONS = ENV.fetch("CONNECTIONS", "5").to_i
-ITERATIONS  = ENV.fetch("ITERATIONS", "100").to_i
-CONCURRENCY = ENV.fetch("CONCURRENCY", "8").to_i  # max in-flight per connection
-
-total_requests = CONNECTIONS * ITERATIONS
-
-Benchmarks::Helpers.print_header(
-  "Rails Concurrent Benchmark (multiplexed)",
-  target:      "#{HOST}:#{PORT}",
-  connections: CONNECTIONS,
-  "reqs/conn": ITERATIONS,
-  concurrency: "#{CONCURRENCY} streams/conn",
-  total:       "#{total_requests * 3} (POST + GET + DELETE)"
-)
-
-mutex = Mutex.new
-results = { post: [], get: [], delete: [] }
-all_created_ids = []
-
-# Fire N requests with at most `concurrency` in-flight at a time on a shared connection.
-def multiplex(count, concurrency:)
-  queue = Queue.new
-  count.times { |i| queue << i }
-
-  threads = concurrency.times.map do
-    Thread.new do
-      while (i = queue.pop(true) rescue nil)
-        yield i
-      end
-    end
-  end
-  threads.each(&:join)
-end
-
-# Phase 1: Concurrent multiplexed POSTs
-puts "\nPhase 1: POST /posts.json (#{CONNECTIONS} conns x #{ITERATIONS}, #{CONCURRENCY} in-flight)..."
-post_elapsed = Benchmark.realtime do
-  conn_threads = CONNECTIONS.times.map do |conn_id|
-    Thread.new do
-      client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
-      client.connect
-
-      local_times = []
-      local_ids = []
-
-      multiplex(ITERATIONS, concurrency: CONCURRENCY) do |i|
-        start = Time.now
-        response = client.post(
-          "/posts.json",
-          headers: { "content-type" => "application/json" },
-          body: { post: { name: "Author #{conn_id}-#{i}", title: "Post #{conn_id}-#{i}" } }.to_json
-        )
-        elapsed = Time.now - start
-
-        if response && response[:status] == 201
-          body = JSON.parse(response[:body]) rescue {}
-          mutex.synchronize do
-            local_times << elapsed
-            local_ids << body["id"] if body["id"]
-          end
-        end
-      end
-
-      client.disconnect
-      mutex.synchronize do
-        results[:post].concat(local_times)
-        all_created_ids.concat(local_ids)
-      end
-    end
-  end
-  conn_threads.each(&:join)
-end
-puts "  #{results[:post].size} created in #{post_elapsed.round(2)}s (#{(results[:post].size / post_elapsed).round(1)} req/s)"
-
-# Phase 2: Concurrent multiplexed GETs
-puts "\nPhase 2: GET /posts.json (#{CONNECTIONS} conns x #{ITERATIONS}, #{CONCURRENCY} in-flight)..."
-get_elapsed = Benchmark.realtime do
-  conn_threads = CONNECTIONS.times.map do
-    Thread.new do
-      client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
-      client.connect
-
-      local_times = []
-
-      multiplex(ITERATIONS, concurrency: CONCURRENCY) do |_i|
-        start = Time.now
-        response = client.get("/posts.json")
-        elapsed = Time.now - start
-
-        if response && response[:status] == 200
-          mutex.synchronize { local_times << elapsed }
-        end
-      end
-
-      client.disconnect
-      mutex.synchronize { results[:get].concat(local_times) }
-    end
-  end
-  conn_threads.each(&:join)
-end
-puts "  #{results[:get].size} fetched in #{get_elapsed.round(2)}s (#{(results[:get].size / get_elapsed).round(1)} req/s)"
-
-# Phase 3: Concurrent multiplexed DELETEs
-delete_count = all_created_ids.size
-puts "\nPhase 3: DELETE /posts/:id (#{delete_count} across #{CONNECTIONS} conns, #{CONCURRENCY} in-flight)..."
-delete_elapsed = Benchmark.realtime do
-  id_chunks = all_created_ids.each_slice((all_created_ids.size.to_f / CONNECTIONS).ceil).to_a
-
-  conn_threads = id_chunks.map do |ids|
-    Thread.new do
-      next if ids.empty?
-
-      client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
-      client.connect
-
-      local_times = []
-
-      multiplex(ids.size, concurrency: CONCURRENCY) do |i|
-        start = Time.now
-        response = client.delete("/posts/#{ids[i]}.json")
-        elapsed = Time.now - start
-
-        if response && response[:status] == 204
-          mutex.synchronize { local_times << elapsed }
-        end
-      end
-
-      client.disconnect
-      mutex.synchronize { results[:delete].concat(local_times) }
-    end
-  end
-  conn_threads.each(&:join)
-end
-puts "  #{results[:delete].size} deleted in #{delete_elapsed.round(2)}s (#{(results[:delete].size / delete_elapsed).round(1)} req/s)"
-
-# Summary
-total_elapsed = post_elapsed + get_elapsed + delete_elapsed
-total_completed = results.values.sum(&:size)
-
-puts
-puts "=" * 70
-puts "RESULTS"
-puts "=" * 70
-Benchmarks::Helpers.print_stats("POST   /posts.json", results[:post])
-Benchmarks::Helpers.print_stats("GET    /posts.json", results[:get])
-Benchmarks::Helpers.print_stats("DELETE /posts/:id ", results[:delete])
-puts "-" * 70
-puts "  Total: #{total_completed} requests in #{total_elapsed.round(2)}s (#{(total_completed / total_elapsed).round(2)} req/s)"
-puts "=" * 70

data/benchmarks/throughput.rb

@@ -1,113 +0,0 @@
-#!/usr/bin/env ruby
-# Throughput benchmark: measures req/sec and latency percentiles.
-# Tests both sequential and concurrent (multiplexed) modes.
-#
-# Self-contained (boots inline server with trivial Rack app):
-#   ruby benchmarks/throughput.rb
-#
-# External server:
-#   HOST=127.0.0.1 PORT=4433 ruby benchmarks/throughput.rb
-
-require_relative "helpers"
-require "benchmark"
-
-REQUESTS    = ENV.fetch("REQUESTS", "500").to_i
-CONNECTIONS = ENV.fetch("CONNECTIONS", "5").to_i
-CONCURRENCY = ENV.fetch("CONCURRENCY", "8").to_i
-HOST        = ENV["HOST"]
-PORT        = ENV["PORT"]&.to_i
-
-def run_benchmark(host, port)
-  # --- Sequential: 1 request at a time per connection ---
-  puts "\n--- Sequential (1 stream/conn, #{CONNECTIONS} conns) ---"
-  seq_times = []
-  mutex = Mutex.new
-
-  seq_elapsed = Benchmark.realtime do
-    per_conn = REQUESTS / CONNECTIONS
-
-    threads = CONNECTIONS.times.map do
-      Thread.new do
-        client = Quicsilver::Client.new(host, port, connection_timeout: 5000, request_timeout: 10)
-        client.connect
-
-        local = []
-        per_conn.times do
-          start = Time.now
-          response = client.get("/")
-          local << (Time.now - start) if response && response[:status] == 200
-        end
-
-        client.disconnect
-        mutex.synchronize { seq_times.concat(local) }
-      end
-    end
-    threads.each(&:join)
-  end
-
-  Benchmarks::Helpers.print_results(
-    total_time: seq_elapsed, total_requests: REQUESTS,
-    times: seq_times, failed: REQUESTS - seq_times.size, latency: true
-  )
-
-  # --- Concurrent: CONCURRENCY streams per connection ---
-  puts "\n--- Concurrent (#{CONCURRENCY} streams/conn, #{CONNECTIONS} conns) ---"
-  con_times = []
-  con_failed = 0
-
-  con_elapsed = Benchmark.realtime do
-    per_conn = REQUESTS / CONNECTIONS
-
-    threads = CONNECTIONS.times.map do
-      Thread.new do
-        client = Quicsilver::Client.new(host, port, connection_timeout: 5000, request_timeout: 10)
-        client.connect
-
-        local = []
-        queue = Queue.new
-        per_conn.times { |i| queue << i }
-
-        workers = CONCURRENCY.times.map do
-          Thread.new do
-            while (queue.pop(true) rescue nil)
-              start = Time.now
-              response = client.get("/bench")
-              dur = Time.now - start
-              if response && response[:status] == 200
-                local << dur
-              else
-                mutex.synchronize { con_failed += 1 }
-              end
-            end
-          end
-        end
-        workers.each(&:join)
-        client.disconnect
-        mutex.synchronize { con_times.concat(local) }
-      end
-    end
-    threads.each(&:join)
-  end
-
-  Benchmarks::Helpers.print_results(
-    total_time: con_elapsed, total_requests: REQUESTS,
-    times: con_times, failed: con_failed, latency: true
-  )
-end
-
-Benchmarks::Helpers.print_header(
-  "Quicsilver Throughput (trivial Rack app, no DB)",
-  connections: CONNECTIONS,
-  "reqs/conn": REQUESTS / CONNECTIONS,
-  concurrency: "#{CONCURRENCY} streams/conn",
-  total: REQUESTS
-)
-
-if HOST && PORT
-  run_benchmark(HOST, PORT)
-else
-  puts "Booting inline server..."
-  Benchmarks::Helpers.with_server(Benchmarks::Helpers.benchmark_app) do |port|
-    run_benchmark("localhost", port)
-  end
-end