quicsilver 0.1.0 → 0.2.0

data/lib/quicsilver/request_registry.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class RequestRegistry
+    def initialize
+      @requests = {}
+      @mutex = Mutex.new
+    end
+
+    def track(stream_id, connection_handle, path:, method:, started_at: Time.now)
+      @mutex.synchronize do
+        @requests[stream_id] = {
+          connection_handle: connection_handle,
+          path: path,
+          method: method,
+          started_at: started_at
+        }
+      end
+    end
+
+    def complete(stream_id)
+      @mutex.synchronize { @requests.delete(stream_id) }
+    end
+
+    def active_count
+      @mutex.synchronize { @requests.size }
+    end
+
+    def active_requests
+      @mutex.synchronize { @requests.dup }
+    end
+
+    def requests_older_than(seconds)
+      cutoff = Time.now - seconds
+      @mutex.synchronize do
+        @requests.select { |_, r| r[:started_at] < cutoff }
+      end
+    end
+
+    def empty?
+      @mutex.synchronize { @requests.empty? }
+    end
+
+    def include?(stream_id)
+      @mutex.synchronize { @requests.key?(stream_id) }
+    end
+  end
+end

data/lib/quicsilver/server.rb

@@ -2,109 +2,22 @@
 
 module Quicsilver
   class Server
-    attr_reader :address, :port, :server_configuration, :running
+    attr_reader :address, :port, :server_configuration, :running, :connections, :request_registry, :shutting_down
 
     STREAM_EVENT_RECEIVE = "RECEIVE"
     STREAM_EVENT_RECEIVE_FIN = "RECEIVE_FIN"
     STREAM_EVENT_CONNECTION_ESTABLISHED = "CONNECTION_ESTABLISHED"
     STREAM_EVENT_SEND_COMPLETE = "SEND_COMPLETE"
+    STREAM_EVENT_CONNECTION_CLOSED = "CONNECTION_CLOSED"
 
-    class << self
-      def stream_buffers
-        @stream_buffers ||= {}
-      end
-
-      def stream_handles
-        @stream_handles ||= {}
-      end
-
-      def rack_app
-        @rack_app
-      end
-
-      def rack_app=(app)
-        @rack_app = app
-      end
-
-      def handle_stream(stream_id, event, data)
-        case event
-        when STREAM_EVENT_CONNECTION_ESTABLISHED
-          puts "🔧 Ruby: Connection established with client"
-          connection_handle = data.unpack1('Q')  # Unpack 64-bit pointer
-          stream = Quicsilver.open_stream(connection_handle, true)  # unidirectional
-          control_data = Quicsilver::HTTP3.build_control_stream
-          Quicsilver.send_stream(stream, control_data, false)  # no FIN
-        when STREAM_EVENT_SEND_COMPLETE
-          puts "🔧 Ruby: Control stream sent to client"
-        when STREAM_EVENT_RECEIVE
-          # Accumulate data
-          stream_buffers[stream_id] ||= ""
-          stream_buffers[stream_id] += data
-          puts "🔧 Ruby: Stream #{stream_id}: Buffering #{data.bytesize} bytes (total: #{stream_buffers[stream_id].bytesize})"
-        when STREAM_EVENT_RECEIVE_FIN
-          # Extract stream handle from data (first 8 bytes)
-          stream_handle = data[0, 8].unpack1('Q')
-          actual_data = data[8..-1] || ""
-
-          # Store stream handle for later use
-          stream_handles[stream_id] = stream_handle
-
-          # Final chunk - process complete message
-          stream_buffers[stream_id] ||= ""
-          stream_buffers[stream_id] += actual_data
-          complete_data = stream_buffers[stream_id]
-
-          # Handle bidirectional streams (client requests)
-          if bidirectional?(stream_id)
-            handle_http3_request(stream_id, complete_data)
-          else
-            # Unidirectional stream (control/QPACK)
-            puts "✅ Ruby: Stream #{stream_id}: Control/QPACK stream (#{complete_data.bytesize} bytes)"
-          end
-
-          # Clean up buffers
-          stream_buffers.delete(stream_id)
-          stream_handles.delete(stream_id)
-        end
-      end
+    ServerStopError = Class.new(StandardError)
 
-      private
+    class << self
+      attr_accessor :instance
 
-      def bidirectional?(stream_id)
-        # Client-initiated bidirectional streams have bit 0x02 clear
-        (stream_id & 0x02) == 0
-      end
-
-      def handle_http3_request(stream_id, data)
-        parser = HTTP3::RequestParser.new(data)
-        parser.parse
-        env = parser.to_rack_env
-
-        if env && rack_app
-          puts "✅ Ruby: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
-
-          # Call Rack app
-          status, headers, body = rack_app.call(env)
-
-          # Encode response
-          encoder = HTTP3::ResponseEncoder.new(status, headers, body)
-          response_data = encoder.encode
-
-          # Get stream handle from stored handles
-          stream_handle = stream_handles[stream_id]
-          if stream_handle
-            # Send response
-            Quicsilver.send_stream(stream_handle, response_data, true)
-            puts "✅ Ruby: Response sent: #{status}"
-          else
-            puts "❌ Ruby: Stream handle not found for stream #{stream_id}"
-          end
-        else
-          puts "❌ Ruby: Failed to parse request"
-        end
-      rescue => e
-        puts "❌ Ruby: Error handling request: #{e.class} - #{e.message}"
-        puts e.backtrace.first(5)
+      # Callback from C extension - delegates to server instance
+      def handle_stream(connection_data, stream_id, event, data)
+        instance&.handle_stream_event(connection_data, stream_id, event, data)
       end
     end
 
@@ -114,30 +27,36 @@ module Quicsilver
       @app = app || default_rack_app
       @server_configuration = server_configuration || ServerConfiguration.new
       @running = false
+      @shutting_down = false
       @listener_data = nil
+      @connections = {}
+      @request_registry = RequestRegistry.new
 
-      # Set class-level rack app so handle_stream can access it
-      self.class.rack_app = @app
+      self.class.instance = self
     end
 
     def start
       raise ServerIsRunningError, "Server is already running" if @running
 
-      # Initialize MSQUIC if not already done
       Quicsilver.open_connection
-
       config = Quicsilver.create_server_configuration(@server_configuration.to_h)
-      unless config
-        raise ServerConfigurationError, "Failed to create server configuration"
-      end
+      raise ServerConfigurationError, "Failed to create server configuration" unless config
 
       # Create and start the listener
-      @listener_data = start_listener(config)
-      start_server(config)
+      result = Quicsilver.create_listener(config)
+      @listener_data = ListenerData.new(result[0], result[1])
+      raise ServerListenerError, "Failed to create listener #{@address}:#{@port}"  unless @listener_data
+
+      unless Quicsilver.start_listener(@listener_data.listener_handle, @address, @port)
+        Quicsilver.close_configuration(config)
+        cleanup_failed_server
+        raise ServerListenerError, "Failed to start listener on #{@address}:#{@port}"
+      end
 
       @running = true
 
-      puts "✅ QUIC server started successfully on #{@address}:#{@port}"
+      Quicsilver.event_loop.start
+      Quicsilver.event_loop.join  # Block until shutdown
     rescue ServerConfigurationError, ServerListenerError => e
       cleanup_failed_server
       @running = false
@@ -161,53 +80,107 @@ module Quicsilver
     def stop
       return unless @running
 
-      puts "🛑 Stopping QUIC server..."
-
-      if @listener_data
-        listener_handle = @listener_data[0]
-        Quicsilver.stop_listener(listener_handle)
-        Quicsilver.close_listener(@listener_data)
-        @listener_data = nil
+      if @listener_data && @listener_data.listener_handle
+        Quicsilver.stop_listener(@listener_data.listener_handle)
+        Quicsilver.close_listener([@listener_data.listener_handle, @listener_data.context_handle])
       end
 
+      Quicsilver.event_loop.stop  # Stop event loop so start unblocks
       @running = false
-      puts "👋 Server stopped"    
-    rescue
-      puts "⚠️  Error during server shutdown"
-      # Continue with cleanup even if there are errors
+      @listener_data = nil
+    rescue => e
       @listener_data = nil
       @running = false
+      raise ServerStopError, "Failed to stop server: #{e.message}"
     end
 
     def running?
       @running
     end
 
-    def server_info
-      {
-        address: @address,
-        port: @port,
-        running: @running,
-        cert_file: @cert_file,
-        key_file: @key_file
-      }
-    end
+    # Graceful shutdown: send GOAWAY, wait for in-flight requests, then stop
+    def shutdown(timeout: 30)
+      return unless @running
+      return if @shutting_down
+
+      @shutting_down = true
+      Quicsilver.logger.info("Initiating graceful shutdown (timeout: #{timeout}s)")
+
+      # Phase 1: Send GOAWAY with max stream ID to all connections
+      # This tells clients to stop sending new requests
+      @connections.each_value do |connection|
+        send_goaway(connection, HTTP3::MAX_STREAM_ID)
+      end
+
+      # Phase 2: Wait for in-flight requests to drain
+      deadline = Time.now + timeout
+      until @request_registry.empty? || Time.now > deadline
+        sleep 0.1
+      end
 
-    def wait_for_connections(timeout: nil)
-      if timeout
-        end_time = Time.now + timeout
-        while Time.now < end_time && @running
-          Quicsilver.process_events
-          sleep(0.01) # Poll every 10ms
+      # Log any requests that didn't complete
+      unless @request_registry.empty?
+        @request_registry.active_requests.each do |stream_id, req|
+          elapsed = Time.now - req[:started_at]
+          Quicsilver.logger.warn("Force-closing request: #{req[:method]} #{req[:path]} (stream: #{stream_id}, elapsed: #{elapsed.round(2)}s)")
         end
-      else
-        # Keep the server running indefinitely
-        # Process events from MSQUIC callbacks
-        loop do
-          Quicsilver.process_events
-          sleep(0.01) # Poll every 10ms
-          break unless @running
+      end
+
+      # Phase 3: Send final GOAWAY with actual last stream ID and shutdown connections
+      @connections.each_value do |connection|
+        last_stream_id = connection.streams.keys.select { |id| (id & 0x02) == 0 }.max || 0
+        send_goaway(connection, last_stream_id)
+
+        # Graceful QUIC shutdown (sends CONNECTION_CLOSE to peer)
+        Quicsilver.connection_shutdown(connection.handle, 0, false)
+      end
+
+      # Give connections a moment to close gracefully
+      sleep 0.1
+
+      # Phase 4: Hard stop
+      stop
+      @shutting_down = false
+
+      Quicsilver.logger.info("Graceful shutdown complete")
+    end
+
+    def handle_stream_event(connection_data, stream_id, event, data)
+      connection_handle = connection_data[0]
+
+      case event
+      when STREAM_EVENT_CONNECTION_ESTABLISHED
+        connection = Connection.new(connection_handle, connection_data)
+        @connections[connection_handle] = connection
+        setup_http3_streams(connection)
+      when STREAM_EVENT_CONNECTION_CLOSED
+        @connections.delete(connection_handle)&.streams&.clear
+      when STREAM_EVENT_SEND_COMPLETE
+        # Buffer cleanup handled in C extension
+      when STREAM_EVENT_RECEIVE
+        return unless connection = @connections[connection_handle]
+
+        stream = connection.get_stream(stream_id) || QuicStream.new(stream_id)
+        connection.add_stream(stream) unless connection.get_stream(stream_id)
+        stream.append_data(data)
+      when STREAM_EVENT_RECEIVE_FIN
+        return unless connection = @connections[connection_handle]
+
+        # Extract stream handle from data (first 8 bytes)
+        stream_handle = data[0, 8].unpack1('Q')
+        actual_data = data[8..-1] || ""
+
+        stream = connection.get_stream(stream_id) || QuicStream.new(stream_id)
+        stream.stream_handle = stream_handle
+        stream.append_data(actual_data)
+
+        if stream.bidirectional?
+          handle_request(connection, stream)
+        else
+          handle_unidirectional_stream(connection, stream) # Unidirectional stream (control/QPACK)
         end
+
+        connection.remove_stream(stream_id)
       end
     end
 
@@ -221,38 +194,162 @@ module Quicsilver
       }
     end
 
-    def start_server(config)
-      result = Quicsilver.start_listener(@listener_data.listener_handle, @address, @port)
-      unless result
-        Quicsilver.close_configuration(config)
-        cleanup_failed_server
-        raise ServerListenerError, "Failed to start listener on #{@address}:#{@port}"
+    def cleanup_failed_server
+      if @listener_data
+        begin
+          Quicsilver.stop_listener(@listener_data.listener_handle) if @listener_data.listener_handle
+          Quicsilver.close_listener([@listener_data.listener_handle, @listener_data.context_handle]) if @listener_data.listener_handle
+        rescue
+          # Ignore cleanup errors
+        ensure
+          @listener_data = nil
+        end
       end
     end
 
-    def start_listener(config)
-      result = Quicsilver.create_listener(config)
-      listener_data = ListenerData.new(result[0], result[1])
+    def setup_http3_streams(connection)
+      connection_data = connection.data
 
-      unless listener_data
-        Quicsilver.close_configuration(config)
-        raise ServerListenerError, "Failed to create listener on #{@address}:#{@port}"
+      # Send control stream (required) - store handle for GOAWAY
+      control_stream = Quicsilver.open_stream(connection_data, true)
+      control_data = HTTP3.build_control_stream
+      Quicsilver.send_stream(control_stream, control_data, false)
+      connection.server_control_stream = control_stream
+
+      # Open QPACK encoder/decoder streams (required)
+      [0x02, 0x03].each do |type|
+        stream = Quicsilver.open_stream(connection_data, true)
+        Quicsilver.send_stream(stream, [type].pack('C'), false)
       end
+    end
+
 
-      listener_data
+    def handle_control_stream(connection, stream)
+      return if stream.data.empty?
+
+      case stream.data[0].ord
+      when 0x00 then connection.set_control_stream(stream.stream_id)
+      when 0x02 then connection.set_qpack_encoder_stream(stream.stream_id)
+      when 0x03 then connection.set_qpack_decoder_stream(stream.stream_id)
+      end
     end
 
-    def cleanup_failed_server
-      if @listener_data
-        begin
-          Quicsilver.stop_listener(@listener_data)
-          Quicsilver.close_listener(@listener_data)
-        rescue
-          # Ignore cleanup errors
-        ensure
-          @listener_data = nil
+    def handle_unidirectional_stream(connection, stream)
+      data = stream.data
+      return if data.empty?
+
+      stream_type = data[0].ord
+      payload = data[1..-1]
+
+      case stream_type
+      when 0x00 # Control stream
+        connection.set_control_stream(stream.stream_id)
+        parse_client_control_stream(payload)
+      when 0x02 # QPACK encoder stream
+        # Store encoder stream for sending dynamic table updates
+        connection.set_qpack_encoder_stream(stream.stream_id)
+      when 0x03 # QPACK decoder stream
+        # Store decoder stream for receiving acknowledgments
+        connection.set_qpack_decoder_stream(stream.stream_id)
+      else
+        raise "⚠️  Ruby: Stream #{stream.stream_id}: Unknown stream type: 0x#{stream_type.to_s(16)}"
+      end
+    end
+
+    def parse_client_control_stream(data)
+      offset = 0
+      while offset < data.bytesize
+        frame_type, type_len = HTTP3.decode_varint(data.bytes, offset)
+        frame_length, length_len = HTTP3.decode_varint(data.bytes, offset + type_len)
+
+        if frame_type == HTTP3::FRAME_SETTINGS
+          # Parse client settings
+          settings_payload = data[offset + type_len + length_len, frame_length]
+          parse_settings_frame(settings_payload)
         end
+
+        offset += type_len + length_len + frame_length
       end
     end
+
+    def parse_settings_frame(payload)
+      offset = 0
+      settings = {}
+
+      while offset < payload.bytesize
+        setting_id, id_len = HTTP3.decode_varint(payload.bytes, offset)
+        setting_value, value_len = HTTP3.decode_varint(payload.bytes, offset + id_len)
+        settings[setting_id] = setting_value
+        offset += id_len + value_len
+      end
+
+      settings
+    end
+
+    def handle_request(connection, stream)
+      parser = HTTP3::RequestParser.new(stream.data)
+      parser.parse
+      env = parser.to_rack_env
+
+      if env && @app
+        # Track request
+        @request_registry.track(
+          stream.stream_id,
+          connection.handle,
+          path: env["PATH_INFO"] || "/",
+          method: env["REQUEST_METHOD"] || "GET"
+        )
+
+        # Call Rack app
+        status, headers, body = @app.call(env)
+        encoder = HTTP3::ResponseEncoder.new(status, headers, body)
+
+        raise "Stream handle not found for stream #{stream.stream_id}" unless stream.ready_to_send?
+
+        # Rack convention: body.to_ary means bufferable, otherwise stream
+        if body.respond_to?(:to_ary)
+          # Buffer mode - small responses (Arrays), send all at once
+          Quicsilver.send_stream(stream.stream_handle, encoder.encode, true)
+        else
+          # Stream mode - lazy bodies (ActionController::Live, SSE), send incrementally
+          encoder.stream_encode do |frame_data, fin|
+            Quicsilver.send_stream(stream.stream_handle, frame_data, fin) unless frame_data.empty? && !fin
+          end
+        end
+
+        # Mark request complete
+        @request_registry.complete(stream.stream_id)
+      else
+        # failed to parse request
+        if stream.ready_to_send?
+          error_response = encode_error_response(400, "Bad Request")
+          Quicsilver.send_stream(stream.stream_handle, error_response, true)
+        end
+      end
+    rescue => e
+      Quicsilver.logger.error("Error handling request: #{e.class} - #{e.message}")
+      Quicsilver.logger.debug(e.backtrace.first(5).join("\n"))
+      error_response = encode_error_response(500, "Internal Server Error")
+
+      Quicsilver.send_stream(stream.stream_handle, error_response, true) if stream.ready_to_send?
+    ensure
+      # Always complete the request, even on error
+      @request_registry.complete(stream.stream_id) if @request_registry.include?(stream.stream_id)
+    end
+
+    def encode_error_response(status, message)
+      body = ["#{status} #{message}"]
+      encoder = HTTP3::ResponseEncoder.new(status, {"content-type" => "text/plain"}, body)
+      encoder.encode
+    end
+
+    def send_goaway(connection, stream_id)
+      return unless connection.server_control_stream
+
+      goaway_frame = HTTP3.build_goaway_frame(stream_id)
+      Quicsilver.send_stream(connection.server_control_stream, goaway_frame, false)
+    rescue => e
+      Quicsilver.logger.error("Failed to send GOAWAY to connection #{connection.handle}: #{e.message}")
+    end
   end
 end

data/lib/quicsilver/server_configuration.rb

@@ -1,23 +1,49 @@
 # frozen_string_literal: true
- 
+
+require "localhost"
+
 module Quicsilver
   class ServerConfiguration
-    attr_reader :cert_file, :key_file, :idle_timeout, :server_resumption_level, :peer_bidi_stream_count, 
-      :peer_unidi_stream_count
+    attr_reader :cert_file, :key_file, :idle_timeout, :server_resumption_level, :peer_bidi_stream_count,
+      :peer_unidi_stream_count, :stream_recv_window, :stream_recv_buffer, :conn_flow_control_window
 
     QUIC_SERVER_RESUME_AND_ZERORTT = 1
     QUIC_SERVER_RESUME_ONLY = 2
     QUIC_SERVER_RESUME_AND_REUSE = 3
     QUIC_SERVER_RESUME_AND_REUSE_ZERORTT = 4
 
+    DEFAULT_CERT_FILE = "certificates/server.crt"
+    DEFAULT_KEY_FILE = "certificates/server.key"
+    DEFAULT_ALPN = "h3"
+
+    # Flow control defaults (msquic defaults)
+    # See: https://github.com/microsoft/msquic/blob/main/docs/Settings.md
+    DEFAULT_STREAM_RECV_WINDOW = 65_536        # 64KB - initial stream receive window
+    DEFAULT_STREAM_RECV_BUFFER = 4_096         # 4KB - stream buffer size
+    DEFAULT_CONN_FLOW_CONTROL_WINDOW = 16_777_216  # 16MB - connection-wide flow control
+
     def initialize(cert_file = nil, key_file = nil, options = {})
-      @cert_file = cert_file.nil? ? "certs/server.crt" : cert_file
-      @key_file = key_file.nil? ? "certs/server.key" : key_file
       @idle_timeout = options[:idle_timeout].nil? ? 10000 : options[:idle_timeout]
       @server_resumption_level = options[:server_resumption_level].nil? ? QUIC_SERVER_RESUME_AND_ZERORTT : options[:server_resumption_level]
       @peer_bidi_stream_count = options[:peer_bidi_stream_count].nil? ? 10 : options[:peer_bidi_stream_count]
       @peer_unidi_stream_count = options[:peer_unidi_stream_count].nil? ? 10 : options[:peer_unidi_stream_count]
-      @alpn = options[:alpn].nil? ? "h3" : options[:alpn]
+      @alpn = options[:alpn].nil? ? DEFAULT_ALPN : options[:alpn]
+
+      # Flow control / backpressure settings
+      @stream_recv_window = options[:stream_recv_window].nil? ? DEFAULT_STREAM_RECV_WINDOW : options[:stream_recv_window]
+      @stream_recv_buffer = options[:stream_recv_buffer].nil? ? DEFAULT_STREAM_RECV_BUFFER : options[:stream_recv_buffer]
+      @conn_flow_control_window = options[:conn_flow_control_window].nil? ? DEFAULT_CONN_FLOW_CONTROL_WINDOW : options[:conn_flow_control_window]
+
+      @cert_file = cert_file.nil? ? DEFAULT_CERT_FILE : cert_file
+      @key_file = key_file.nil? ? DEFAULT_KEY_FILE : key_file
+
+      unless File.exist?(@cert_file)
+        raise ServerConfigurationError, "Certificate file not found: #{@cert_file}"
+      end
+
+      unless File.exist?(@key_file)
+        raise ServerConfigurationError, "Key file not found: #{@key_file}"
+      end
     end
 
     # Common HTTP/3 ALPN Values:
@@ -42,7 +68,10 @@ module Quicsilver
         server_resumption_level: @server_resumption_level,
         peer_bidi_stream_count: @peer_bidi_stream_count,
         peer_unidi_stream_count: @peer_unidi_stream_count,
-        alpn: alpn
+        alpn: alpn,
+        stream_recv_window: @stream_recv_window,
+        stream_recv_buffer: @stream_recv_buffer,
+        conn_flow_control_window: @conn_flow_control_window
       }
     end
   end

data/lib/quicsilver/version.rb

@@ -1,3 +1,3 @@
 module Quicsilver
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/quicsilver.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require "logger"
 require_relative "quicsilver/version"
 require_relative "quicsilver/client"
+require_relative "quicsilver/connection"
+require_relative "quicsilver/event_loop"
+require_relative "quicsilver/quic_stream"
 require_relative "quicsilver/listener_data"
+require_relative "quicsilver/request_registry"
 require_relative "quicsilver/server"
 require_relative "quicsilver/server_configuration"
 require_relative "quicsilver/http3"
@@ -10,6 +15,7 @@ require_relative "quicsilver/http3/request_parser"
 require_relative "quicsilver/http3/request_encoder"
 require_relative "quicsilver/http3/response_encoder"
 require_relative "quicsilver/quicsilver"
+require_relative "rackup/handler/quicsilver"
 
 module Quicsilver
   class Error < StandardError; end
@@ -19,4 +25,20 @@ module Quicsilver
   class ServerError < Error; end
   class ConnectionError < Error; end
   class TimeoutError < Error; end
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= default_logger
+    end
+
+    private
+
+    def default_logger
+      Logger.new($stdout, level: Logger::INFO).tap do |log|
+        log.progname = "Quicsilver"
+      end
+    end
+  end
 end