quicsilver 0.1.0 → 0.3.0

data/benchmarks/concurrent.rb

@@ -0,0 +1,110 @@
+#!/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/helpers.rb

@@ -0,0 +1,88 @@
+require "bundler/setup"
+require "quicsilver"
+require "localhost/authority"
+
+module Benchmarks
+  module Helpers
+    # Boot a Quicsilver server on a random port, yield the port, then tear down.
+    def self.with_server(app, &block)
+      authority = Localhost::Authority.fetch
+      config = Quicsilver::Transport::Configuration.new(
+        authority.certificate_path,
+        authority.key_path
+      )
+
+      port = random_port
+      server = Quicsilver::Server.new(port, app: app, server_configuration: config)
+      server_thread = Thread.new { server.start }
+      sleep 0.5 # let listener settle
+
+      yield port
+    ensure
+      server&.stop rescue nil
+      server_thread&.join(2)
+    end
+
+    # Compute latency stats from an array of float durations (in seconds).
+    # Returns a Hash with :avg, :min, :max, :p50, :p95, :p99 (all in ms).
+    def self.stats(times)
+      return nil if times.empty?
+
+      sorted = times.sort
+      n = sorted.size
+      {
+        count: n,
+        avg:   (times.sum / n * 1000).round(2),
+        min:   (sorted.first * 1000).round(2),
+        max:   (sorted.last * 1000).round(2),
+        p50:   (sorted[n / 2] * 1000).round(2),
+        p95:   (sorted[(n * 0.95).to_i] * 1000).round(2),
+        p99:   (sorted[(n * 0.99).to_i] * 1000).round(2)
+      }
+    end
+
+    def self.print_header(title, **opts)
+      puts
+      puts "=" * 60
+      puts title
+      puts "=" * 60
+      opts.each { |k, v| puts "  #{k}: #{v}" }
+      puts "-" * 60
+    end
+
+    def self.print_stats(label, times)
+      s = stats(times)
+      unless s
+        puts "  #{label}: no data"
+        return
+      end
+      puts "  #{label}: #{s[:count]} reqs | avg=#{s[:avg]}ms p50=#{s[:p50]}ms p95=#{s[:p95]}ms p99=#{s[:p99]}ms (min=#{s[:min]}ms max=#{s[:max]}ms)"
+    end
+
+    def self.print_results(total_time:, total_requests:, times:, failed: 0, latency: false)
+      s = stats(times)
+      puts "-" * 60
+      puts "  Total time:  #{total_time.round(3)}s"
+      puts "  Requests:    #{total_requests} (#{failed} failed)"
+      puts "  Throughput:  #{(total_requests / total_time).round(2)} req/s"
+      if latency && s
+        puts "  Latency:     avg=#{s[:avg]}ms p50=#{s[:p50]}ms p95=#{s[:p95]}ms p99=#{s[:p99]}ms"
+        puts "               min=#{s[:min]}ms max=#{s[:max]}ms"
+      end
+      puts "=" * 60
+    end
+
+    def self.random_port
+      server = TCPServer.new("127.0.0.1", 0)
+      server.addr[1]
+    ensure
+      server&.close
+    end
+
+    def self.benchmark_app
+      ->(env) {
+        [200, { "content-type" => "text/plain" }, ["OK"]]
+      }
+    end
+  end
+end

data/benchmarks/quicsilver_server.rb

@@ -0,0 +1,46 @@
+#!/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

@@ -0,0 +1,170 @@
+#!/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

@@ -0,0 +1,113 @@
+#!/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

data/examples/minimal_http3_server.rb

@@ -6,12 +6,6 @@ require "quicsilver"
 puts "🚀 Minimal HTTP/3 Server Example"
 puts "=" * 40
 
-# First, set up certificates if they don't exist
-unless File.exist?("certs/server.crt") && File.exist?("certs/server.key")
-  puts "📝 Setting up certificates..."
-  system("bash examples/setup_certs.sh")
-end
-
 # Create and start the server
 server = Quicsilver::Server.new(4433)
 

data/examples/rack_http3_server.rb

@@ -6,12 +6,6 @@ require "quicsilver"
 puts "🚀 Rack HTTP/3 Server Example"
 puts "=" * 40
 
-# First, set up certificates if they don't exist
-unless File.exist?("certs/server.crt") && File.exist?("certs/server.key")
-  puts "📝 Setting up certificates..."
-  system("bash examples/setup_certs.sh")
-end
-
 # Define a simple Rack app
 app = ->(env) {
   path = env['PATH_INFO']

data/examples/simple_client_test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "quicsilver"
+
+puts "🔌 Simple HTTP/3 Client Test"
+puts "=" * 40
+
+begin
+  client = Quicsilver::Client.new("127.0.0.1", 4433, unsecure: true)
+
+  client.connect
+
+  response = client.get("/posts")
+
+  puts "Status: #{response[:status]}"
+  puts "Headers: #{response[:headers].inspect}"
+  puts "Body: #{response[:body]}"
+
+rescue => e
+  puts "❌ Error: #{e.class} - #{e.message}"
+  puts e.backtrace.first(10)
+ensure
+  client&.disconnect
+  puts "👋 Done"
+end