quicsilver 0.4.0 → 0.5.0

data/lib/quicsilver/transport/inbound_stream.rb

@@ -14,7 +14,7 @@ module Quicsilver
       end
 
       def bidirectional?
-        (stream_id & 0x02) == 0
+        StreamId.bidirectional?(stream_id)
       end
 
       def writable?
@@ -28,6 +28,26 @@ module Quicsilver
       def data
         @buffer.string
       end
+
+      def send(data, fin: false)
+        return unless writable?
+        Quicsilver.send_stream(@stream_handle, data, fin)
+      end
+
+      def reset(error_code = Protocol::H3_REQUEST_CANCELLED)
+        return unless writable?
+        Quicsilver.stream_reset(@stream_handle, error_code)
+      end
+
+      def stop_sending(error_code = Protocol::H3_REQUEST_CANCELLED)
+        return unless writable?
+        Quicsilver.stream_stop_sending(@stream_handle, error_code)
+      end
+
+      def abort(error_code = Protocol::H3_REQUEST_CANCELLED)
+        return unless writable?
+        Quicsilver.stream_abort(@stream_handle, error_code)
+      end
     end
   end
 end

data/lib/quicsilver/transport/stream.rb

@@ -2,9 +2,7 @@
 
 module Quicsilver
   module Transport
-    # Wraps a QUIC stream opened by Ruby code (client requests, server control streams).
-    # Encapsulates the C handle — callers use send/reset/stop_sending methods instead
-    # of passing raw pointers to Quicsilver.send_stream etc.
+    # The handle is an opaque native registry token, not a pointer.
     class Stream
       attr_reader :handle
 
@@ -12,10 +10,23 @@ module Quicsilver
         @handle = handle
       end
 
+      # Returns nil until asynchronous stream startup completes, or after shutdown.
+      def stream_id
+        Quicsilver.get_stream_id(@handle)
+      end
+
       def send(data, fin: false)
         Quicsilver.send_stream(@handle, data, fin)
       end
 
+      def reliable_offset=(offset)
+        Quicsilver.set_stream_reliable_offset(@handle, offset)
+      end
+
+      def grant_receive_credit(bytes, chunks)
+        Quicsilver.grant_stream_receive_credit(@handle, bytes, chunks)
+      end
+
       def reset(error_code = Protocol::H3_REQUEST_CANCELLED)
         Quicsilver.stream_reset(@handle, error_code)
       end
@@ -23,6 +34,10 @@ module Quicsilver
       def stop_sending(error_code = Protocol::H3_REQUEST_CANCELLED)
         Quicsilver.stream_stop_sending(@handle, error_code)
       end
+
+      def abort(error_code = Protocol::H3_REQUEST_CANCELLED)
+        Quicsilver.stream_abort(@handle, error_code)
+      end
     end
   end
 end

data/lib/quicsilver/transport/stream_event.rb

@@ -5,22 +5,45 @@ module Quicsilver
     # Parses the binary data packed by the C extension for stream completion events.
     # C packs events as:
     #   RECEIVE_FIN:  [stream_handle(8)][payload...]
-    #   STREAM_RESET: [stream_handle(8)][error_code(8)]
+    #   STREAM_RESET: [stream_handle(8)][error_code(8)][final_size(8)]
     #   STOP_SENDING: [stream_handle(8)][error_code(8)]
     class StreamEvent
+      # A reset stream's final size is unknown to MsQuic until RESET_STREAM or
+      # FIN settles it; the C extension reports that as this sentinel so it
+      # never has to be confused with a real length.
+      FINAL_SIZE_UNKNOWN = (2**64) - 1
+
       attr_reader :handle, :data, :error_code
 
+      # The total number of bytes the peer sent on this stream, from the
+      # RESET_STREAM frame (RFC 9000 4.5). nil when it is not settled or the
+      # event does not carry one. WebTransport session flow control needs it to
+      # charge the bytes a reset discarded (draft-ietf-webtrans-http3-16 5.4).
+      attr_reader :final_size
+
       def initialize(raw_data, event_type)
         @handle = raw_data[0, 8].unpack1("Q")
         remaining = raw_data[8..] || "".b
 
         case event_type
-        when "RECEIVE_FIN"
+        when "RECEIVE", "RECEIVE_FIN"
           @data = remaining
         when "STREAM_RESET", "STOP_SENDING"
           @error_code = remaining.unpack1("Q")
+          @final_size = parse_final_size(remaining)
         end
       end
+
+      private
+
+      # Older packings carry only the error code, so a missing final size is
+      # not an error.
+      def parse_final_size(remaining)
+        return unless remaining.bytesize >= 16
+
+        value = remaining.unpack1("@8Q")
+        value unless value == FINAL_SIZE_UNKNOWN
+      end
     end
   end
 end

data/lib/quicsilver/transport/stream_id.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Transport
+    module StreamId
+      INITIATOR_MASK = 0x01
+      DIRECTION_MASK = 0x02
+      REQUEST_STREAM_MASK = INITIATOR_MASK | DIRECTION_MASK
+
+      module_function
+
+      def bidirectional?(stream_id)
+        (stream_id & DIRECTION_MASK).zero?
+      end
+
+      def unidirectional?(stream_id)
+        !bidirectional?(stream_id)
+      end
+
+      # HTTP/3 requests run on client-initiated bidirectional QUIC streams.
+      def request?(stream_id)
+        (stream_id & REQUEST_STREAM_MASK).zero?
+      end
+    end
+  end
+end

data/lib/quicsilver/version.rb

@@ -1,3 +1,3 @@
 module Quicsilver
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/quicsilver.rb

@@ -2,9 +2,15 @@
 
 require "logger"
 require_relative "quicsilver/version"
+require_relative "quicsilver/errors"
+require_relative "quicsilver/response"
 
 # Protocol layer
 require_relative "quicsilver/protocol/frames"
+require_relative "quicsilver/protocol/datagram"
+require_relative "quicsilver/protocol/capsule"
+require_relative "quicsilver/protocol/web_transport"
+require_relative "quicsilver/protocol/unidirectional_stream"
 require_relative "quicsilver/protocol/priority"
 require_relative "quicsilver/protocol/qpack/encoder"
 require_relative "quicsilver/protocol/request_parser"
@@ -17,18 +23,26 @@ require_relative "quicsilver/protocol/adapter"
 require_relative "quicsilver/protocol/control_stream_parser"
 require "protocol/rack"
 
+# Rack integration
+require_relative "quicsilver/rack/context"
+
 # Transport layer
+require_relative "quicsilver/transport/stream_id"
 require_relative "quicsilver/transport/stream"
 require_relative "quicsilver/transport/stream_event"
 require_relative "quicsilver/transport/inbound_stream"
 require_relative "quicsilver/transport/event_loop"
 require_relative "quicsilver/transport/configuration"
 require_relative "quicsilver/transport/connection"
+require_relative "quicsilver/transport/connection_stats"
 
 # Server
 require_relative "quicsilver/server/listener_data"
 require_relative "quicsilver/server/request_registry"
 require_relative "quicsilver/server/request_handler"
+require_relative "quicsilver/server/rack_adapter"
+require_relative "quicsilver/server/web_transport_flow_control"
+require_relative "quicsilver/server/web_transport_manager"
 require_relative "quicsilver/server/server"
 
 # Client
@@ -37,29 +51,26 @@ require_relative "quicsilver/client/connection_pool"
 require_relative "quicsilver/client/client"
 
 # C extension
-# Load precompiled binary if available, fall back to native extension
 begin
   ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
-  require_relative "quicsilver/#{ruby_version}/quicsilver"
+  require "quicsilver/#{ruby_version}/quicsilver"
 rescue LoadError
-  require_relative "quicsilver/quicsilver"
+  require "quicsilver/quicsilver"
 end
 
 # Rackup handler
 require_relative "rackup/handler/quicsilver"
 
 module Quicsilver
-  class Error < StandardError; end
-  class ServerIsRunningError < Error; end
-  class ServerConfigurationError < Error; end
-  class ServerListenerError < Error; end
-  class ServerError < Error; end
-  class ConnectionError < Error; end
-  class TimeoutError < Error; end
-
   class << self
     attr_writer :logger
 
+    def stream_abort(handle, error_code)
+      receiving_stopped = stream_stop_sending(handle, error_code)
+      sending_reset = stream_reset(handle, error_code)
+      receiving_stopped || sending_reset
+    end
+
     def logger
       @logger ||= default_logger
     end

data/lib/rackup/handler/quicsilver.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "rackup/handler"
-require "localhost"
 
 module Quicsilver
   module RackHandler
@@ -10,54 +9,74 @@ module Quicsilver
       Port: 4433,
     }
 
-    def self.run(app, **options)
-      normalized_options = {
-        host: options[:Host] || options[:host] || DEFAULT_OPTIONS[:Host],
-        port: (options[:Port] || options[:port] || DEFAULT_OPTIONS[:Port]).to_i,
-      }
+    class << self
+      def run(app, **options)
+        normalized_options = {
+          host: options[:Host] || options[:host] || DEFAULT_OPTIONS[:Host],
+          port: (options[:Port] || options[:port] || DEFAULT_OPTIONS[:Port]).to_i,
+        }
 
-      cert_file = options[:cert_file]
-      key_file = options[:key_file]
+        cert_file, key_file = certificate_paths(options)
+        config = ::Quicsilver::Transport::Configuration.new(cert_file, key_file)
 
-      if cert_file.nil? && key_file.nil?
-        env = options[:environment] || ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+        server = ::Quicsilver::Server.new(
+          normalized_options[:port],
+          address: normalized_options[:host],
+          app: app,
+          server_configuration: config
+        )
 
-        if env == 'production'
-          raise ArgumentError, "cert_file and key_file are required in production"
+        yield server if block_given?
+
+        server.start
+      end
+
+      def valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: 0.0.0.0)",
+          "Port=PORT" => "Port to listen on (default: 4433)",
+          "cert_file=PATH" => "Path to TLS certificate file (required in production)",
+          "key_file=PATH" => "Path to TLS key file (required in production)"
+        }
+      end
+
+      private
+
+      def certificate_paths(options)
+        cert_file = options[:cert_file]
+        key_file = options[:key_file]
+
+        if cert_file.nil? && key_file.nil?
+          if production?(options)
+            raise ArgumentError, "cert_file and key_file are required in production"
+          else
+            localhost_certificate_paths
+          end
+        elsif cert_file.nil? || key_file.nil?
+          raise ArgumentError, "cert_file and key_file must be provided together"
         else
-          require 'localhost/authority'
-          authority = Localhost::Authority.fetch
-          cert_file = authority.certificate_path
-          key_file = authority.key_path
-          Quicsilver.logger.info("Using auto-generated certificates for localhost")
-          Quicsilver.logger.info("  Cert: #{cert_file}")
-          Quicsilver.logger.info("  Key: #{key_file}")
+          [cert_file, key_file]
         end
       end
 
-      config = ::Quicsilver::Transport::Configuration.new(cert_file, key_file)
-
-      server = ::Quicsilver::Server.new(
-        normalized_options[:port],
-        address: normalized_options[:host],
-        app: app,
-        server_configuration: config
-      )
+      def production?(options)
+        env = options[:environment] || ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+        env == "production"
+      end
 
-      yield server if block_given?
+      def localhost_certificate_paths
+        require "localhost/authority"
+        authority = Localhost::Authority.fetch
+        cert_file = authority.certificate_path
+        key_file = authority.key_path
 
-      server.start
-    end
+        Quicsilver.logger.info("Using auto-generated certificates for localhost")
+        Quicsilver.logger.info("  Cert: #{cert_file}")
+        Quicsilver.logger.info("  Key: #{key_file}")
 
-    def self.valid_options
-      {
-        "Host=HOST" => "Hostname to listen on (default: 0.0.0.0)",
-        "Port=PORT" => "Port to listen on (default: 4433)",
-        "cert_file=PATH" => "Path to TLS certificate file (required)",
-        "key_file=PATH" => "Path to TLS key file (required)"
-      }
+        [cert_file, key_file]
+      end
     end
-
   end
 end
 

data/quicsilver.gemspec

@@ -30,9 +30,15 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|vendor)/}) }
-    # Include precompiled binaries if present
-    files += Dir["lib/quicsilver/libmsquic*"]
-    files += Dir["lib/quicsilver/quicsilver.{bundle,so}"]
+
+    if ENV["RELEASE"]
+      if RUBY_PLATFORM.include?("darwin")
+        files += Dir["lib/quicsilver/libmsquic*.dylib"]
+      elsif RUBY_PLATFORM.include?("linux")
+        files += Dir["lib/quicsilver/libmsquic.so*"]
+      end
+    end
+
     files
   end
   spec.bindir        = "exe"
@@ -46,6 +52,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency 'rake-compiler', '~> 1.2'
   spec.add_development_dependency 'rake-compiler-dock', '~> 1.3'
+  spec.add_development_dependency "cibuildgem"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "minitest-focus", "~> 1.3"
   spec.add_development_dependency "benchmark-ips", "~> 2.12"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: quicsilver
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Haroon Ahmed
 bindir: exe
 cert_chain: []
-date: 2026-04-25 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
@@ -224,14 +238,16 @@ 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
@@ -239,23 +255,38 @@ files:
 - 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/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
@@ -270,17 +301,32 @@ files:
 - lib/quicsilver/protocol/response_parser.rb
 - lib/quicsilver/protocol/stream_input.rb
 - lib/quicsilver/protocol/stream_output.rb
-- lib/quicsilver/quicsilver.bundle
+- 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
@@ -306,7 +352,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !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.open_connection
-
-  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.open_connection
-
-        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