quicsilver 0.3.0 → 0.4.0

data/examples/protocol_http_server.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Running a Rack app with protocol-http as the internal layer
+#
+# quicsilver uses protocol-http Request/Response internally.
+# Rack apps are automatically wrapped — no code changes needed.
+#
+# Modes:
+#   :rack (default) — Rack app, wrapped with Protocol::Rack::Adapter
+#   :falcon         — native protocol-http app, no wrapping
+
+require_relative "example_helper"
+
+# Any standard Rack app works
+app = ->(env) {
+  puts "#{env['REQUEST_METHOD']} #{env['PATH_INFO']} #{env['SERVER_PROTOCOL']}"
+
+  body = "Hello from Quicsilver!\n" \
+         "Method: #{env['REQUEST_METHOD']}\n" \
+         "Path: #{env['PATH_INFO']}\n" \
+         "Protocol: #{env['SERVER_PROTOCOL']}\n"
+
+  [200, { "content-type" => "text/plain" }, [body]]
+}
+
+server = Quicsilver::Server.new(4433, app: app, server_configuration: EXAMPLE_TLS_CONFIG)
+
+puts "Starting Quicsilver on https://localhost:4433"
+puts "Test with: curl --http3 -k https://localhost:4433/"
+server.start

data/examples/rack_http3_server.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "quicsilver"
+require_relative "example_helper"
 
 puts "🚀 Rack HTTP/3 Server Example"
 puts "=" * 40
@@ -31,24 +30,13 @@ app = ->(env) {
   end
 }
 
-# Create and start the server with the Rack app
-server = Quicsilver::Server.new(4433, app: app)
+server = Quicsilver::Server.new(4433, app: app, server_configuration: EXAMPLE_TLS_CONFIG)
 
-puts "🔧 Starting server..."
-server.start
-
-puts "✅ Server is running on port 4433"
 puts "📋 Try these requests:"
-puts "   curl --http3 -k https://127.0.0.1:4433/"
-puts "   curl --http3 -k https://127.0.0.1:4433/api/users"
-puts "   curl --http3 -k https://127.0.0.1:4433/api/status"
+puts "   curl --http3 -k https://localhost:4433/"
+puts "   curl --http3 -k https://localhost:4433/api/users"
+puts "   curl --http3 -k https://localhost:4433/api/status"
+puts "⏳ Press Ctrl+C to stop."
+puts
 
-# Keep the server running
-puts "⏳ Server is running. Press Ctrl+C to stop..."
-begin
-  server.wait_for_connections
-rescue Interrupt
-  puts "\n🛑 Stopping server..."
-  server.stop
-  puts "👋 Server stopped"
-end
+server.start

data/examples/rails_feature_test.rb

@@ -0,0 +1,260 @@
+#!/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("Multiple requests reuse the same connection") do
+  5.times 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)
+    puts "    Request #{i}: #{elapsed}ms (#{i == 0 ? 'new connection' : 'same connection'})"
+  end
+  puts "    Pool: #{Quicsilver::Client.pool.size} connection(s)"
+  raise "Pool should have 1 connection" unless Quicsilver::Client.pool.size == 1
+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. Multiplexing (Sequential on single connection) ===
+puts "\n6️⃣  Multiplexing (10 requests, single connection)"
+puts "-" * 60
+
+test("10 sequential requests on one connection") do
+  client = Quicsilver::Client.new(HOST, PORT, unsecure: true)
+  t_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  10.times { client.get("/h3/ping") }
+  total = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t_start) * 1000).round(1)
+  puts "    10 requests in #{total}ms (single connection)"
+  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 Multiplexing ===
+puts "\n9️⃣  Concurrent Multiplexing"
+puts "-" * 60
+
+test("4 concurrent requests on separate connections") do
+  threads = 4.times.map do |i|
+    Thread.new 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)
+      [i, response[:status], elapsed]
+    end
+  end
+  results = threads.map(&:value).sort_by(&:first)
+  results.each { |i, status, elapsed| puts "    Stream #{i}: #{status} — #{elapsed}ms" }
+  total = results.map { |_, _, e| e }.max
+  # All 4 should complete in roughly the same time (~200ms) not 4x (800ms)
+  raise "Expected concurrent, took #{total}ms" if total > 600
+  puts "    All 4 concurrent in #{total}ms (not #{200 * 4}ms sequential)"
+end
+
+# === 10. Large Upload ===
+puts "\n🔟  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 "\n1️⃣1️⃣  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. 0-RTT Reconnection ===
+puts "\n1️⃣2️⃣  0-RTT Reconnection"
+puts "-" * 60
+
+test("Two separate connections show handshake cost") 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
+
+  sleep 0.1
+
+  # Second connection — new handshake (0-RTT depends on MsQuic session cache)
+  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
+
+  puts "    First connection:  #{first}ms"
+  puts "    Second connection: #{second}ms"
+  puts "    Pooling saves: ~#{first}ms per request by avoiding handshakes"
+end
+
+# === 13. GOAWAY Graceful Shutdown ===
+puts "\n1️⃣3️⃣  GOAWAY (server keeps serving during test)"
+puts "-" * 60
+
+test("Server responds after many requests (no GOAWAY yet)") do
+  response = Quicsilver::Client.get(HOST, PORT, "/h3/ping", unsecure: true)
+  raise "Expected 200" unless response[:status] == 200
+  puts "    Server still healthy after all tests"
+end
+
+# === 14. Rails CRUD ===
+puts "\n1️⃣4️⃣  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 "\n1️⃣5️⃣  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/simple_client_test.rb

@@ -7,11 +7,11 @@ 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}"

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"
+
+PORT = 4433
+HOST = "localhost"
+
+app = ->(env) {
+  path = env["PATH_INFO"]
+
+  case path
+  when "/stream-with-checksum"
+    # Stream data, then send a checksum trailer
+    body = ["chunk1\n", "chunk2\n", "chunk3\n"]
+    checksum = Digest::SHA256.hexdigest(body.join)[0..7]
+
+    [200,
+     { "content-type" => "text/plain", "trailer" => "x-checksum" },
+     body]
+    # Note: trailers via Rack need the protocol-rack convention
+    # (see autoresearch.ideas.md for the Samuel Williams discussion)
+
+  when "/grpc-style"
+    # gRPC-style response: status comes in trailers, not headers
+    body = ['{"result":"processed"}']
+
+    [200,
+     { "content-type" => "application/json" },
+     body]
+
+  else
+    [200, { "content-type" => "text/plain" }, ["Try /stream-with-checksum or /grpc-style"]]
+  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 "\n  gRPC-style response:"
+response = client.get("/grpc-style")
+puts "    Status: #{response[:status]}"
+puts "    Body: #{response[:body]}"
+
+puts "\n  Trailer support is built into the protocol layer."
+puts "  ResponseEncoder can send trailers after DATA frames."
+puts "  Full Rack integration needs protocol-rack update."
+
+client.disconnect
+server.stop
+server_thread.join(2)
+puts "\n✅ Done"

data/ext/quicsilver/extconf.rb

@@ -1,5 +1,19 @@
 require 'mkmf'
 
+# Skip compilation if precompiled binary is already present
+ext_dir = File.expand_path('../../lib/quicsilver', __dir__)
+if File.exist?(File.join(ext_dir, 'quicsilver.bundle')) || File.exist?(File.join(ext_dir, 'quicsilver.so'))
+  File.write('Makefile', "install:\n\t@echo 'Using precompiled binary'\n\nall:\n\t@echo 'Using precompiled binary'\n")
+  exit
+end
+
+# On macOS, use Apple clang if available. Homebrew clang can't find
+# system headers and produces broken binaries with MsQuic.
+if RUBY_PLATFORM =~ /darwin/ && File.exist?("/usr/bin/clang")
+  RbConfig::CONFIG["CC"] = "/usr/bin/clang"
+  RbConfig::MAKEFILE_CONFIG["CC"] = "/usr/bin/clang"
+end
+
 # Find MSQUIC in the submodule
 msquic_dir = File.expand_path('../../../vendor/msquic', __FILE__)
 

data/ext/quicsilver/quicsilver.c

@@ -79,6 +79,12 @@ typedef struct {
     QUIC_STATUS error_status;
 } StreamContext;
 
+// Pending stream priorities — set from Ruby threads, applied on MsQuic event thread.
+// Simple array-based storage (max 256 pending). Key = stream handle, value = priority + 1.
+#define MAX_PENDING_PRIORITIES 256
+static struct { HQUIC stream; uint16_t priority_plus_one; } PendingPriorities[MAX_PENDING_PRIORITIES];
+static int PendingPriorityCount = 0;
+
 // rb_protect wrapper — catches Ruby exceptions so they don't longjmp
 // through MsQuic callback frames (which would corrupt MsQuic state).
 // All Ruby object construction AND the funcall happen inside rb_protect.
@@ -273,6 +279,17 @@ StreamCallback(HQUIC Stream, void* Context, QUIC_STREAM_EVENT* Event)
         return QUIC_STATUS_SUCCESS;
     }
 
+    // Apply pending priority on the event loop thread (safe context for SetParam)
+    for (int i = 0; i < PendingPriorityCount; i++) {
+        if (PendingPriorities[i].stream == Stream) {
+            uint16_t priority = PendingPriorities[i].priority_plus_one - 1;
+            // Remove by swapping with last
+            PendingPriorities[i] = PendingPriorities[--PendingPriorityCount];
+            MsQuic->SetParam(Stream, QUIC_PARAM_STREAM_PRIORITY, sizeof(priority), &priority);
+            break;
+        }
+    }
+
     switch (Event->Type) {
         case QUIC_STREAM_EVENT_RECEIVE: {
             int has_fin = (Event->RECEIVE.Flags & QUIC_RECEIVE_FLAG_FIN) != 0;
@@ -1215,6 +1232,27 @@ quicsilver_stream_reset(VALUE self, VALUE stream_handle, VALUE error_code)
     return Qtrue;
 }
 
+// Queue a stream priority change. Called from Ruby threads — just stores the
+// priority. The actual SetParam happens on the MsQuic event thread in StreamCallback.
+static VALUE
+quicsilver_set_stream_priority(VALUE self, VALUE stream_handle, VALUE priority)
+{
+    if (MsQuic == NULL) return Qnil;
+
+    HQUIC Stream = (HQUIC)(uintptr_t)NUM2ULL(stream_handle);
+    if (Stream == NULL) return Qnil;
+
+    if (PendingPriorityCount >= MAX_PENDING_PRIORITIES) return Qfalse;
+
+    uint16_t Priority = (uint16_t)NUM2UINT(priority);
+    PendingPriorities[PendingPriorityCount].stream = Stream;
+    PendingPriorities[PendingPriorityCount].priority_plus_one = Priority + 1;
+    PendingPriorityCount++;
+
+    wake_event_loop();
+    return Qtrue;
+}
+
 // Stop sending on a QUIC stream (STOP_SENDING frame - requests peer to stop)
 static VALUE
 quicsilver_stream_stop_sending(VALUE self, VALUE stream_handle, VALUE error_code)
@@ -1277,6 +1315,7 @@ Init_quicsilver(void)
     rb_define_singleton_method(mQuicsilver, "send_stream", quicsilver_send_stream, 3);
     rb_define_singleton_method(mQuicsilver, "stream_reset", quicsilver_stream_reset, 2);
     rb_define_singleton_method(mQuicsilver, "stream_stop_sending", quicsilver_stream_stop_sending, 2);
+    rb_define_singleton_method(mQuicsilver, "set_stream_priority", quicsilver_set_stream_priority, 2);
 
     // Event processing (custom execution — app drives MsQuic)
     rb_define_singleton_method(mQuicsilver, "poll", quicsilver_poll, 0);