quicsilver 0.3.0 → 0.5.0

data/examples/rails_feature_test.rb

@@ -0,0 +1,280 @@
+#!/usr/bin/env ruby
+
+# Tests all major quicsilver features against a running Rails app.
+#
+# Prerequisites:
+#   1. Start the Rails app: cd blogz && bundle exec rackup -s quicsilver -p 4433
+#   2. Run this script:     cd quicsilver && bundle exec ruby examples/rails_feature_test.rb
+#
+# Tests: ping, streaming, priorities, echo, HEAD, multiplexing, connection pooling
+
+require "bundler/setup"
+require "quicsilver"
+
+HOST = "localhost"
+PORT = 4433
+PASS = "✅"
+FAIL = "❌"
+
+def test(name)
+  result = yield
+  puts "  #{PASS} #{name}"
+  result
+rescue => e
+  puts "  #{FAIL} #{name}: #{e.message}"
+  nil
+end
+
+puts "Quicsilver Rails Feature Test"
+puts "   Target: https://#{HOST}:#{PORT}"
+puts "=" * 60
+
+# === 1. Basic connectivity ===
+puts "\n1. Basic Connectivity"
+puts "-" * 60
+
+test("GET /h3/ping returns JSON over HTTP/3") do
+  response = Quicsilver::Client.get(HOST, PORT, "/h3/ping", unsecure: true)
+  raise "Expected 200, got #{response.status}" unless response.status == 200
+  raise "Expected JSON" unless response.body.include?('"status":"ok"')
+  raise "Expected HTTP/3" unless response.body.include?("HTTP/3")
+  puts "    Response: #{response.body}"
+end
+
+# === 2. Connection Pooling ===
+puts "\n2. Connection Pooling"
+puts "-" * 60
+
+test("5 requests reuse one connection (no repeat handshakes)") do
+  Quicsilver::Client.close_pool
+  times = 5.times.map do |i|
+    t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    Quicsilver::Client.get(HOST, PORT, "/h3/ping", unsecure: true)
+    elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t) * 1000).round(1)
+    label = i == 0 ? "new connection + handshake" : "reused"
+    puts "    Request #{i}: #{elapsed}ms (#{label})"
+    elapsed
+  end
+  puts "    Pool: #{Quicsilver::Client.pool.size} connection(s)"
+  raise "Pool should have 1 connection" unless Quicsilver::Client.pool.size == 1
+  # First request includes handshake, subsequent should be faster on average
+  avg_reused = times[1..].sum / times[1..].size
+  puts "    First request: #{times[0]}ms, avg reused: #{avg_reused.round(1)}ms"
+end
+
+# === 3. Streaming ===
+puts "\n3. Streaming Response"
+puts "-" * 60
+
+test("GET /h3/stream returns chunked SSE data") do
+  response = Quicsilver::Client.get(HOST, PORT, "/h3/stream", unsecure: true)
+  raise "Expected 200" unless response.status == 200
+  chunks = response.body.scan(/data: chunk \d+/)
+  raise "Expected 5 chunks, got #{chunks.size}" unless chunks.size == 5
+  puts "    Received #{chunks.size} streamed chunks"
+end
+
+# === 4. POST with Body (Echo) ===
+puts "\n4. POST with Body"
+puts "-" * 60
+
+test("POST /h3/echo returns the request body") do
+  body = '{"message": "Hello HTTP/3!"}'
+  response = Quicsilver::Client.post(HOST, PORT, "/h3/echo",
+    body: body,
+    headers: { "content-type" => "application/json" },
+    unsecure: true)
+  raise "Expected 200" unless response.status == 200
+  raise "Body not echoed" unless response.body.include?("Hello HTTP/3!")
+  puts "    Echoed: #{response.body[0..80]}"
+end
+
+# === 5. HEAD Request ===
+puts "\n5. HEAD Request"
+puts "-" * 60
+
+test("HEAD /h3/head returns headers but no body") do
+  client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+  response = client.head("/h3/head")
+  raise "Expected 200" unless response.status == 200
+  raise "HEAD should have empty body" unless response.body.nil? || response.body.empty?
+  puts "    Status: #{response.status}, body size: #{response.body&.bytesize || 0}"
+  client.disconnect
+end
+
+# === 6. True Multiplexing (concurrent streams, single connection) ===
+puts "\n6. True Multiplexing (concurrent streams, single connection)"
+puts "-" * 60
+
+test("10 concurrent requests on one connection") do
+  client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+  client.get("/h3/ping") # warmup + handshake
+
+  t_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  requests = 10.times.map { client.build_request("GET", "/h3/ping") }
+  responses = requests.map { |r| r.response(timeout: 10) }
+  total = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t_start) * 1000).round(1)
+
+  ok = responses.count { |r| r.status == 200 }
+  rps = (10 / (total / 1000.0)).round(0)
+  puts "    10 concurrent requests in #{total}ms (#{ok}/10 ok, #{rps} req/s)"
+  raise "Not all 200" unless ok == 10
+  client.disconnect
+end
+
+# === 7. Priority Endpoints (CSS vs Image) ===
+puts "\n7. Priority Endpoints"
+puts "-" * 60
+
+test("GET /h3/css returns CSS content") do
+  response = Quicsilver::Client.get(HOST, PORT, "/h3/css", unsecure: true)
+  raise "Expected 200" unless response.status == 200
+  puts "    CSS: #{response.body.bytesize} bytes"
+end
+
+test("GET /h3/image returns large binary payload") do
+  response = Quicsilver::Client.get(HOST, PORT, "/h3/image", unsecure: true)
+  raise "Expected 200" unless response.status == 200
+  raise "Expected 50KB" unless response.body.bytesize == 50_000
+  puts "    Image: #{response.body.bytesize} bytes"
+end
+
+# === 8. Slow Response (Delay) ===
+puts "\n8. Slow Response"
+puts "-" * 60
+
+test("GET /h3/slow?delay=0.2 respects delay") do
+  t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  response = Quicsilver::Client.get(HOST, PORT, "/h3/slow?delay=0.2", unsecure: true)
+  elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t) * 1000).round(1)
+  raise "Expected 200" unless response.status == 200
+  raise "Should take ~200ms, took #{elapsed}ms" unless elapsed > 150
+  puts "    Delayed response in #{elapsed}ms"
+end
+
+# === 9. Concurrent Connections ===
+puts "\n9. Concurrent Connections (4 threads, 4 connections)"
+puts "-" * 60
+
+test("4 concurrent requests on separate connections complete in parallel") do
+  Quicsilver::Client.close_pool
+  threads = 4.times.map do |i|
+    Thread.new do
+      client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+      t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      response = client.get("/h3/slow?delay=0.2")
+      elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t) * 1000).round(1)
+      client.disconnect
+      [i, response.status, elapsed]
+    end
+  end
+  results = threads.map(&:value).sort_by(&:first)
+  results.each { |i, status, elapsed| puts "    Connection #{i}: #{status} -- #{elapsed}ms" }
+  total = results.map { |_, _, e| e }.max
+  sequential = 200 * 4
+  puts "    Total: #{total}ms (sequential would be ~#{sequential}ms)"
+end
+
+# === 10. Large Upload ===
+puts "\n10. Large Upload"
+puts "-" * 60
+
+test("POST 100KB body") do
+  big_body = "x" * 100_000
+  response = Quicsilver::Client.post(HOST, PORT, "/h3/upload",
+    body: big_body,
+    headers: { "content-type" => "application/octet-stream" },
+    unsecure: true)
+  raise "Expected 200" unless response.status == 200
+  raise "Size mismatch" unless response.body.include?('"received_bytes":100000')
+  puts "    Uploaded 100KB, server received 100,000 bytes"
+end
+
+# === 11. Content-Length Validation ===
+puts "\n11. Content-Length Validation"
+puts "-" * 60
+
+test("POST with content-length header") do
+  body = "hello"
+  response = Quicsilver::Client.post(HOST, PORT, "/h3/upload",
+    body: body,
+    headers: { "content-type" => "text/plain" },
+    unsecure: true)
+  raise "Expected 200, got #{response.status}" unless response.status == 200
+  raise "Size mismatch" unless response.body.include?('"received_bytes":5')
+  puts "    Sent 5 bytes, server received 5 bytes"
+end
+
+# === 12. Handshake Cost (connection pooling benefit) ===
+puts "\n12. Handshake Cost"
+puts "-" * 60
+
+test("Fresh connections pay handshake cost -- pooling avoids this") do
+  Quicsilver::Client.close_pool
+
+  # First connection -- full handshake
+  client1 = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  client1.get("/h3/ping")
+  first = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t1) * 1000).round(1)
+  client1.disconnect
+
+  # Second connection -- another full handshake
+  client2 = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+  t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  client2.get("/h3/ping")
+  second = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t2) * 1000).round(1)
+  client2.disconnect
+
+  # Pooled -- reuses existing connection, no handshake
+  Quicsilver::Client.close_pool
+  Quicsilver::Client.get(HOST, PORT, "/h3/ping", unsecure: true) # establish
+  t3 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  Quicsilver::Client.get(HOST, PORT, "/h3/ping", unsecure: true)
+  pooled = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t3) * 1000).round(1)
+
+  puts "    Fresh connection 1: #{first}ms"
+  puts "    Fresh connection 2: #{second}ms"
+  puts "    Pooled (no handshake): #{pooled}ms"
+end
+
+# === 13. Server Health ===
+puts "\n13. Server Health"
+puts "-" * 60
+
+test("Server still responding after all tests") do
+  response = Quicsilver::Client.get(HOST, PORT, "/h3/ping", unsecure: true)
+  raise "Expected 200" unless response.status == 200
+  puts "    Server healthy"
+end
+
+# === 14. Rails CRUD ===
+puts "\n14. Rails CRUD"
+puts "-" * 60
+
+test("GET /posts.json returns posts array") do
+  response = Quicsilver::Client.get(HOST, PORT, "/posts.json", unsecure: true)
+  raise "Expected 200" unless response.status == 200
+  puts "    Posts: #{response.body[0..40]}"
+end
+
+# === 15. HTTP Methods ===
+puts "\n15. HTTP Methods"
+puts "-" * 60
+
+client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+%i[get post put patch delete head].each do |method|
+  test("#{method.to_s.upcase} /h3/ping") do
+    response = client.public_send(method, "/h3/ping")
+    body_size = response.body&.bytesize || 0
+    puts "    #{response.status} (#{body_size} bytes)"
+  end
+end
+client.disconnect
+
+# === Summary ===
+puts "\n" + "=" * 60
+puts "Feature test complete!"
+puts "   Pool: #{Quicsilver::Client.pool.size} connection(s)"
+Quicsilver::Client.close_pool
+puts "Done"

data/examples/server_stats.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Demonstrates Quicsilver::Server#stats.
+#
+#   ruby examples/server_stats.rb
+#   PORT=4444 ruby examples/server_stats.rb
+#
+# The stats snapshot combines:
+#   - Quicsilver app-server state: running, connections, active requests, queue.
+#   - QUIC transport counters: process-wide connection/stream/packet/worker state.
+
+require_relative "example_helper"
+require "json"
+
+HOST = ENV.fetch("HOST", "localhost")
+PORT = Integer(ENV.fetch("PORT", "4433"))
+
+server = nil
+server_thread = nil
+clients = []
+
+begin
+app = ->(env) {
+  case env["PATH_INFO"]
+  when "/hello"
+    [200, { "content-type" => "text/plain" }, ["hello\n"]]
+  when %r{\A/slow}
+    sleep 0.25
+    [200, { "content-type" => "text/plain" }, ["slow response\n"]]
+  else
+    [404, { "content-type" => "text/plain" }, ["not found\n"]]
+  end
+}
+
+server = Quicsilver::Server.new(PORT, app: app, server_configuration: EXAMPLE_TLS_CONFIG)
+server_thread = Thread.new { server.start }
+
+# Keep examples self-contained without requiring test helpers.
+def wait_until(timeout: 3)
+  deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+  until yield
+    raise "timed out waiting" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+    sleep 0.01
+  end
+end
+
+wait_until { server.running? }
+
+# Print the useful subset first, then include the whole transport hash so it is
+# easy to see every counter name currently exposed by Quicsilver.transport_counters.
+def print_stats(title, server)
+  stats = server.stats
+  transport = stats["transport"] || {}
+
+  puts "\n#{title}"
+  puts "-" * title.length
+  puts JSON.pretty_generate(
+    "server" => {
+      "running" => stats["running"],
+      "shutting_down" => stats["shutting_down"],
+      "connections" => stats["connections"],
+      "requests" => stats["requests"],
+      "scheduler" => stats["scheduler"]
+    },
+    "transport_summary" => {
+      "connections_active" => transport["connections_active"],
+      "connections_connected" => transport["connections_connected"],
+      "streams_active" => transport["streams_active"],
+      "connection_queue_depth" => transport["connection_queue_depth"],
+      "connection_operations_queue_depth" => transport["connection_operations_queue_depth"],
+      "worker_operations_queue_depth" => transport["worker_operations_queue_depth"],
+      "connections_load_rejected" => transport["connections_load_rejected"],
+      "packets_dropped" => transport["packets_dropped"],
+      "app_bytes_received" => transport["app_bytes_received"],
+      "app_bytes_sent" => transport["app_bytes_sent"]
+    },
+    "transport" => transport
+  )
+end
+
+puts "Quicsilver Server Stats Demo"
+puts "Listening on https://#{HOST}:#{PORT}"
+puts "Note: transport counters are process-wide, so they include this example's clients too."
+
+print_stats("1. Fresh server", server)
+
+clients = 2.times.map { Quicsilver::Client.new(HOST, PORT, unsecure: true) }
+clients.each_with_index do |client, index|
+  response = client.get("/hello")
+  puts "client #{index + 1}: GET /hello -> #{response.status}"
+end
+
+wait_until { server.stats.dig("connections", "active") >= 2 }
+print_stats("2. After two client connections", server)
+
+slow_requests = clients.each_with_index.map do |client, index|
+  Thread.new do
+    response = client.get("/slow/#{index + 1}")
+    puts "client #{index + 1}: GET /slow/#{index + 1} -> #{response.status}"
+  end
+end
+
+wait_until { server.stats.dig("requests", "active") >= 2 }
+print_stats("3. While slow requests are in flight", server)
+
+slow_requests.each(&:join)
+print_stats("4. After slow requests complete", server)
+
+puts "\nDone."
+ensure
+  clients.each { |client| client.disconnect rescue nil }
+  Quicsilver::Client.close_pool rescue nil
+  server&.stop rescue nil
+  server_thread&.join(2)
+end

data/examples/simple_client_test.rb

@@ -7,15 +7,15 @@ puts "🔌 Simple HTTP/3 Client Test"
 puts "=" * 40
 
 begin
-  client = Quicsilver::Client.new("127.0.0.1", 4433, unsecure: true)
+  client = Quicsilver::Client.new("localhost", 4433, unsecure: true)
 
   client.connect
 
-  response = client.get("/posts")
+  response = client.get("/")
 
-  puts "Status: #{response[:status]}"
-  puts "Headers: #{response[:headers].inspect}"
-  puts "Body: #{response[:body]}"
+  puts "Status: #{response.status}"
+  puts "Headers: #{response.headers.inspect}"
+  puts "Body: #{response.body}"
 
 rescue => e
   puts "❌ Error: #{e.class} - #{e.message}"

data/examples/streaming_sse.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+# Server-Sent Events over HTTP/3.
+#
+# Demonstrates streaming responses — data arrives chunk by chunk,
+# not buffered. Each chunk is sent as a separate HTTP/3 DATA frame.
+#
+#   ruby examples/streaming_sse.rb
+#   curl --http3-only -k https://localhost:4433/
+
+require_relative "example_helper"
+
+app = ->(env) {
+  body = Enumerator.new do |y|
+    10.times do |i|
+      y << "data: {\"count\":#{i},\"time\":\"#{Time.now.iso8601}\"}\n\n"
+      sleep 0.2
+    end
+    y << "data: {\"done\":true}\n\n"
+  end
+
+  [200, { "content-type" => "text/event-stream", "cache-control" => "no-cache" }, body]
+}
+
+server = Quicsilver::Server.new(4433, app: app, server_configuration: EXAMPLE_TLS_CONFIG)
+
+puts "📡 Streaming SSE over HTTP/3"
+puts "   https://localhost:4433"
+puts "   curl --http3-only -k https://localhost:4433/"
+puts "   Events arrive every 200ms — no buffering."
+puts
+
+server.start

data/examples/trailers.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+# HTTP/3 Trailers — send headers after the body.
+#
+# Trailers let the server report status after streaming is complete.
+# Useful for checksums, streaming error status, and gRPC.
+#
+#   ruby examples/trailers.rb
+
+require_relative "example_helper"
+require "digest"
+
+PORT = 4433
+HOST = "localhost"
+
+app = ->(env) {
+  path = env["PATH_INFO"]
+
+  case path
+  when "/stream-with-checksum"
+    body = ["chunk1\n", "chunk2\n", "chunk3\n"]
+    checksum = Digest::SHA256.hexdigest(body.join)[0..7]
+    env["rack.trailers"] = { "x-checksum" => checksum }
+    [200, { "content-type" => "text/plain" }, body]
+
+  when "/grpc-style"
+    env["rack.trailers"] = { "grpc-status" => "0", "grpc-message" => "OK" }
+    [200, { "content-type" => "application/grpc" }, ['{"result":"processed"}']]
+
+  when "/grpc-error"
+    env["rack.trailers"] = { "grpc-status" => "13", "grpc-message" => "INTERNAL" }
+    [200, { "content-type" => "application/grpc" }, ['{"error":"something broke"}']]
+
+  else
+    [200, { "content-type" => "text/plain" }, ["Try /stream-with-checksum, /grpc-style, or /grpc-error"]]
+  end
+}
+
+server = Quicsilver::Server.new(PORT, app: app, server_configuration: EXAMPLE_TLS_CONFIG)
+server_thread = Thread.new { server.start }
+sleep 0.3
+
+puts "HTTP/3 Trailers Demo"
+puts "=" * 50
+
+client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+
+puts "\n  Streaming with checksum trailer:"
+response = client.get("/stream-with-checksum")
+puts "    Status:   #{response.status}"
+puts "    Body:     #{response.body.inspect}"
+puts "    Trailers: #{response.trailers}"
+
+puts "\n  gRPC-style success:"
+response = client.get("/grpc-style")
+puts "    Status:   #{response.status}"
+puts "    Body:     #{response.body}"
+puts "    Trailers: #{response.trailers}"
+
+puts "\n  gRPC-style error:"
+response = client.get("/grpc-error")
+puts "    Status:   #{response.status}"
+puts "    Body:     #{response.body}"
+puts "    Trailers: #{response.trailers}"
+
+client.disconnect
+server.stop
+server_thread.join(2)
+puts "\nDone"