quicsilver 0.1.0 → 0.2.0

data/lib/quicsilver/client.rb

@@ -1,37 +1,50 @@
 # frozen_string_literal: true
 
+require_relative 'http3/request_encoder'
+require_relative 'http3/response_parser'
+require_relative "event_loop"
+require "timeout"
+
 module Quicsilver
   class Client
     attr_reader :hostname, :port, :unsecure, :connection_timeout
-    
+
+    AlreadyConnectedError = Class.new(StandardError)
+    NotConnectedError = Class.new(StandardError)
+    StreamFailedToOpenError = Class.new(StandardError)
+
+    FINISHED_EVENTS = %w[RECEIVE_FIN RECEIVE].freeze
+
     def initialize(hostname, port = 4433, options = {})
       @hostname = hostname
       @port = port
-      @unsecure = options[:unsecure] || true
-      @connection_timeout = options[:connection_timeout] || 5000
-   
+      @unsecure = options.fetch(:unsecure, true)
+      @connection_timeout = options.fetch(:connection_timeout, 5000)
+
       @connection_data = nil
       @connected = false
       @connection_start_time = nil
+
+      @response_buffers = {}  # stream_id => accumulated data
+      @pending_requests = {}
+      @mutex = Mutex.new
     end
     
     def connect
-      raise Error, "Already connected" if @connected
+      raise AlreadyConnectedError if @connected
 
-      # Initialize MSQUIC if not already done
-      result = Quicsilver.open_connection
+      Quicsilver.open_connection
       
-      # Create configuration
       config = Quicsilver.create_configuration(@unsecure)
       raise ConnectionError, "Failed to create configuration" if config.nil?
-      
+
       # Create connection (returns [handle, context])
-      @connection_data = Quicsilver.create_connection
+      # Pass self so C extension can route callbacks to this instance
+      @connection_data = Quicsilver.create_connection(self)
       raise ConnectionError, "Failed to create connection" if @connection_data.nil?
       
-      connection_handle = @connection_data[0]
-      context_handle = @connection_data[1]
-      
+      connection_handle, context_handle = @connection_data
+
       # Start the connection
       success = Quicsilver.start_connection(connection_handle, config, @hostname, @port)
       unless success
@@ -40,30 +53,17 @@ module Quicsilver
         raise ConnectionError, "Failed to start connection"
       end
 
-      # Wait for connection to establish or fail
       result = Quicsilver.wait_for_connection(context_handle, @connection_timeout)
-
-      if result.key?("error")
-        error_status = result["status"]
-        error_code = result["code"]
-        Quicsilver.close_configuration(config)
-        cleanup_failed_connection
-        error_msg = "Connection failed with status: 0x#{error_status.to_s(16)}, code: #{error_code}"
-        raise ConnectionError, error_msg
-      elsif result.key?("timeout")
-        Quicsilver.close_configuration(config)
-        cleanup_failed_connection
-        error_msg = "Connection timed out after #{@connection_timeout}ms"
-        raise TimeoutError, error_msg
-      end
+      handle_connection_result(result, config)
       
       @connected = true
       @connection_start_time = Time.now
-      
+
       send_control_stream
-      
-      # Clean up config since connection is established
-      Quicsilver.close_configuration(config)
+      Quicsilver.close_configuration(config) # Clean up config since connection is established
+
+      Quicsilver.event_loop.start
+      self
     rescue => e
       cleanup_failed_connection
       
@@ -75,68 +75,86 @@ module Quicsilver
     end
     
     def disconnect
-      return unless @connected || @connection_data
-      
-      begin
-        if @connection_data
-          Quicsilver.close_connection_handle(@connection_data)
-          @connection_data = nil
-        end
-      rescue
-        # Ignore disconnect errors
-      ensure
-        @connected = false
-        @connection_start_time = nil
+      return unless @connection_data
+
+      @connected = false
+
+      # Wake up pending requests
+      @mutex.synchronize do
+        @pending_requests.each_value { |q| q.push(nil) }
+        @pending_requests.clear
+        @response_buffers.clear
       end
+
+      Quicsilver.close_connection_handle(@connection_data) if @connection_data
+      @connection_data = nil
     end
-    
-    def connected?
-      return false unless @connected && @connection_data
-
-      # Get connection status from the C extension
-      context_handle = @connection_data[1]
-      info = Quicsilver.connection_status(context_handle)
-      if info && info.key?("connected")
-        is_connected = info["connected"] && !info["failed"]
-        
-        # If C extension says we're disconnected, update our state
-        if !is_connected && @connected
-          @connected = false
-        end
-        
-        is_connected
-      else
-        # If we can't get status, assume disconnected
-        if @connected
-          @connected = false
-        end
-        false
+
+    def get(path, **opts)
+      request("GET", path, **opts)
+    end
+
+    def post(path, **opts)
+      request("POST", path, **opts)
+    end
+
+    def patch(path, **opts)
+      request("PATCH", path, **opts)
+    end
+
+    def delete(path, **opts)
+      request("DELETE", path, **opts)
+    end
+
+    def head(path, **opts)
+      request("HEAD", path, **opts)
+    end
+
+    def request(method, path, headers: {}, body: nil, timeout: 5000)
+      raise NotConnectedError unless @connected
+      response_queue = Queue.new
+
+      request = HTTP3::RequestEncoder.new(
+        method: method,
+        path: path,
+        scheme: "https",
+        authority: authority,
+        headers: headers,
+        body: body
+      )
+
+      stream = open_stream
+      raise StreamFailedToOpenError unless stream
+
+      @mutex.synchronize do
+        @pending_requests[stream] = response_queue
       end
-    rescue
-      # If there's an error checking status, assume disconnected
-      if @connected
-        @connected = false
+
+      # Send data with FIN flag
+      result = Quicsilver.send_stream(stream, request.encode, true)
+
+      unless result
+        @mutex.synchronize { @pending_requests.delete(stream) }
+        raise Error, "Failed to send request"
       end
-      false
+
+      response = response_queue.pop(timeout: timeout / 1000.0)
+
+      raise ConnectionError, "Connection closed" if response.nil? && !@connected
+      raise TimeoutError, "Request timeout after #{timeout}ms" if response.nil?
+
+      response
+    rescue Timeout::Error
+      @mutex.synchronize { @pending_requests.delete(stream) } if stream
+    end
+
+    def connected?
+      @connected && @connection_data && connection_alive?
     end
     
     def connection_info
-      base_info = if @connection_data
-        begin
-          context_handle = @connection_data[1]
-          Quicsilver.connection_status(context_handle) || {}
-        rescue
-          {}
-        end
-      else
-        {}
-      end
-      
-      base_info.merge({
-        hostname: @hostname,
-        port: @port,
-        uptime: connection_uptime
-      })
+      info = @connection_data ? Quicsilver.connection_status(@connection_data[1]) : {}
+      info.merge(hostname: @hostname, port: @port, uptime: connection_uptime)
     end
     
     def connection_uptime
@@ -144,21 +162,50 @@ module Quicsilver
       Time.now - @connection_start_time
     end
 
-    def send_data(data)
-      raise Error, "Not connected" unless @connected
+    def authority
+      "#{@hostname}:#{@port}"
+    end
 
-      stream = open_stream
-      unless stream
-        puts "❌ Failed to open stream"
-        return false
-      end
+    # Called directly by C extension via process_events
+    # C extension routes to this instance based on client_obj stored in connection context
+    # Clients should never call this method directly.
+    def handle_stream_event(stream_id, event, data)
+      return unless FINISHED_EVENTS.include?(event)
+
+      @mutex.synchronize do
+        case event
+        when "RECEIVE"
+          @response_buffers[stream_id] ||= StringIO.new
+          @response_buffers[stream_id].write(data) # Buffer incoming response data
+        when "RECEIVE_FIN"
+          stream_handle = data[0, 8].unpack1('Q') if data.bytesize >= 8
+          actual_data = data[8..-1] || ""
+
+          # Get all buffered data
+          buffer = @response_buffers.delete(stream_id)
+          full_data = ( buffer&.string || "") + actual_data
 
-      result = Quicsilver.send_stream(stream, data, true)
-      puts "✅ Sent #{data.bytesize} bytes"
-      result
+          # TODO: needed for streaming later
+          @stream_handles ||= {}
+          @stream_handles[stream_id] = stream_handle if stream_handle
+
+          response_parser = Quicsilver::HTTP3::ResponseParser.new(full_data)
+          response_parser.parse
+
+          # Store complete response with body as string
+          response = {
+            status: response_parser.status,
+            headers: response_parser.headers,
+            body: response_parser.body.read
+          }
+
+          queue = @pending_requests.delete(stream_handle)
+          queue&.push(response)  # Unblocks request
+        end
+      end
     rescue => e
-      puts "❌ Send data error: #{e.class} - #{e.message}"
-      false
+      Quicsilver.logger.error("Error handling client stream: #{e.class} - #{e.message}")
+      Quicsilver.logger.debug(e.backtrace.first(5).join("\n"))
     end
     
     private
@@ -170,11 +217,11 @@ module Quicsilver
     end
 
     def open_stream
-      Quicsilver.open_stream(@connection_data[0], false)
+      Quicsilver.open_stream(@connection_data, false)
     end
 
     def open_unidirectional_stream
-      Quicsilver.open_stream(@connection_data[0], true)
+      Quicsilver.open_stream(@connection_data, true)
     end
 
     def send_control_stream
@@ -187,5 +234,28 @@ module Quicsilver
 
       @control_stream = stream
     end
+
+    def handle_connection_result(result, config)
+      if result.key?("error")
+        error_status = result["status"]
+        error_code = result["code"]
+        Quicsilver.close_configuration(config)
+        cleanup_failed_connection
+        error_msg = "Connection failed with status: 0x#{error_status.to_s(16)}, code: #{error_code}"
+        raise ConnectionError, error_msg
+      elsif result.key?("timeout")
+        Quicsilver.close_configuration(config)
+        cleanup_failed_connection
+        error_msg = "Connection timed out after #{@connection_timeout}ms"
+        raise TimeoutError, error_msg
+      end
+    end
+
+    def connection_alive?
+      return false unless (info = Quicsilver.connection_status(@connection_data[1]))
+      info["connected"] && !info["failed"]
+    rescue
+      false
+    end
   end
 end

data/lib/quicsilver/connection.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Connection
+    attr_reader :handle, :data, :control_stream_id, :qpack_encoder_stream_id, :qpack_decoder_stream_id
+    attr_reader :streams
+    attr_accessor :server_control_stream  # Handle for server's outbound control stream (used to send GOAWAY)
+
+    def initialize(handle, data)
+      @handle = handle
+      @data = data
+      @streams = {}
+      @control_stream_id = nil
+      @qpack_encoder_stream_id = nil
+      @qpack_decoder_stream_id = nil
+    end
+
+    def set_qpack_encoder_stream(stream_id)
+      @qpack_encoder_stream_id = stream_id
+    end
+
+    def set_qpack_decoder_stream(stream_id)
+      @qpack_decoder_stream_id = stream_id
+    end
+
+    def set_control_stream(stream_id)
+      @control_stream_id = stream_id
+    end
+
+    def add_stream(stream)
+      @streams[stream.stream_id] = stream
+    end
+
+    def get_stream(stream_id)
+      @streams[stream_id]
+    end
+
+    def remove_stream(stream_id)
+      @streams.delete(stream_id)
+    end
+  end
+end

data/lib/quicsilver/event_loop.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class EventLoop
+    def initialize
+      @running = false
+      @thread = nil
+      @mutex = Mutex.new
+    end
+
+    def start
+      @mutex.synchronize do
+        return if @running
+
+        @running = true
+        @thread = Thread.new do
+          while @running
+            processed = Quicsilver.process_events
+            processed == 0 ? sleep(0.001) : Thread.pass
+          end
+        end
+      end
+    end
+
+    def stop
+      @running = false
+      @thread&.join(2)
+    end
+
+    def join
+      @thread&.join
+    end
+  end
+
+  def self.event_loop
+    @event_loop ||= EventLoop.new.tap(&:start)
+  end
+end

data/lib/quicsilver/http3/request_encoder.rb

@@ -17,12 +17,12 @@ module Quicsilver
 
         # Build HEADERS frame
         headers_payload = encode_headers
-        frames << build_frame(0x01, headers_payload)  # 0x01 = HEADERS frame
+        frames << build_frame(HTTP3::FRAME_HEADERS, headers_payload)
 
         # Build DATA frame if body present
         if @body && !@body.empty?
           body_data = @body.is_a?(String) ? @body : @body.join
-          frames << build_frame(0x00, body_data)  # 0x00 = DATA frame
+          frames << build_frame(HTTP3::FRAME_DATA, body_data)
         end
 
         frames.join.force_encoding(Encoding::BINARY)
@@ -69,30 +69,51 @@ module Quicsilver
       # Literal field line with literal name for pseudo-headers
       # Pattern: 0x50 (indexed name from static table) + value
       def encode_literal_pseudo_header(name, value)
-        # For pseudo-headers, use indexed name reference from static table
-        # with literal value (pattern: 0101xxxx where xxxx = static table index)
-        static_index = case name
-        when ':authority' then 0
-        when ':path' then 1
-        when ':method' then (@method == 'GET' ? 17 : 20)  # GET=17, POST=20
-        when ':scheme' then (@scheme == 'http' ? 22 : 23)
-        else nil
-        end
+        result = "".b
 
-        if static_index
-          # Use indexed field line (0x40 | index)
-          result = "".b
-          result += [0x40 | static_index].pack('C')
-          # For non-exact matches, append literal value
-          if name == ':authority' || name == ':path'
+        case name
+        when ':method'
+          # Check if exact match in static table
+          index = case @method
+          when 'GET' then HTTP3::QPACK_METHOD_GET
+          when 'POST' then HTTP3::QPACK_METHOD_POST
+          when 'PUT' then HTTP3::QPACK_METHOD_PUT
+          when 'DELETE' then HTTP3::QPACK_METHOD_DELETE
+          when 'CONNECT' then HTTP3::QPACK_METHOD_CONNECT
+          when 'HEAD' then HTTP3::QPACK_METHOD_HEAD
+          when 'OPTIONS' then HTTP3::QPACK_METHOD_OPTIONS
+          else nil
+          end
+
+          if index
+            # Exact match - use indexed field line (0x80 | index)
+            result += [0x80 | index].pack('C')
+          else
+            # No exact match - use literal with name reference
+            result += [0x40 | HTTP3::QPACK_METHOD_GET].pack('C')  # Use any :method index for name
             result += HTTP3.encode_varint(value.bytesize)
-            result += value.to_s.b
+            result += value.b
           end
-          result
+
+        when ':scheme'
+          # Check if exact match
+          index = (@scheme == 'https' ? HTTP3::QPACK_SCHEME_HTTPS : HTTP3::QPACK_SCHEME_HTTP)
+          # Exact match - use indexed field line
+          result += [0x80 | index].pack('C')
+
+        when ':authority', ':path'
+          # Name in static table, but value is custom - use literal with name reference
+          index = (name == ':authority' ? HTTP3::QPACK_AUTHORITY : HTTP3::QPACK_PATH)
+          result += [0x40 | index].pack('C')
+          result += HTTP3.encode_varint(value.bytesize)
+          result += value.b
+
         else
           # Fallback to literal name
-          encode_literal_header(name, value)
+          return encode_literal_header(name, value)
         end
+
+        result
       end
 
       # Literal field line with literal name

data/lib/quicsilver/http3/request_parser.rb

@@ -12,6 +12,7 @@ module Quicsilver
         @frames = []
         @headers = {}
         @body = StringIO.new
+        @body.set_encoding(Encoding::ASCII_8BIT)
       end
 
       def parse
@@ -49,10 +50,21 @@ module Quicsilver
           'CONTENT_LENGTH' => @body.size.to_s,
         }
 
-        # Add regular headers as HTTP_*
+        # Add HTTP_HOST from :authority pseudo-header
+        if @headers[':authority']
+          env['HTTP_HOST'] = @headers[':authority']
+        end
+
         @headers.each do |name, value|
           next if name.start_with?(':')
-          env["HTTP_#{name.upcase.tr('-', '_')}"] = value
+          key = name.upcase.tr('-', '_')
+          if key == 'CONTENT_TYPE'
+            env['CONTENT_TYPE'] = value
+          elsif key == 'CONTENT_LENGTH'
+            env['CONTENT_LENGTH'] = value
+          else
+            env["HTTP_#{key}"] = value
+          end
         end
 
         env
@@ -97,26 +109,35 @@ module Quicsilver
         while offset < payload.bytesize
           byte = payload.bytes[offset]
 
-          # Indexed field line (static table, starts with 0x4X or 0x5X)
-          if (byte & 0xC0) == 0x40 || (byte & 0xC0) == 0x80
+          # Pattern 1: Indexed Field Line (1Txxxxxx)
+          # Use both name AND value from static table
+          if (byte & 0x80) == 0x80
             index = byte & 0x3F
             offset += 1
 
-            # Check if this is a complete field (name+value) or just name
             field = decode_static_table_field(index)
-
             if field.is_a?(Hash)
-              # Complete field with both name and value (e.g., :method GET)
               @headers.merge!(field)
-            elsif field
-              # Name-only entry, value follows
+            end
+          # Pattern 3: Literal with Name Reference (01NTxxxx)
+          # Use name from static table, but value is provided as literal
+          elsif (byte & 0xC0) == 0x40
+            index = byte & 0x3F
+            offset += 1
+
+            # Get the name from static table
+            entry = HTTP3::STATIC_TABLE[index] if index < HTTP3::STATIC_TABLE.size
+            name = entry ? entry[0] : nil
+
+            if name
+              # Read literal value that follows
               value_len, len_bytes = HTTP3.decode_varint(payload.bytes, offset)
               offset += len_bytes
               value = payload[offset, value_len]
               offset += value_len
-              @headers[field] = value
+              @headers[name] = value
             end
-          # Literal with literal name (starts with 0x2X)
+          # Pattern 5: Literal with literal name (001NHxxx)
           elsif (byte & 0xE0) == 0x20
             name_len = byte & 0x1F
             offset += 1
@@ -138,19 +159,16 @@ module Quicsilver
       # QPACK static table decoder (RFC 9204 Appendix A)
       # Returns Hash for complete fields, String for name-only fields
       def decode_static_table_field(index)
-        case index
-        when 0 then ':authority'        # Name only
-        when 1 then ':path'             # Name only
-        when 15 then {':method' => 'CONNECT'}
-        when 16 then {':method' => 'DELETE'}
-        when 17 then {':method' => 'GET'}
-        when 18 then {':method' => 'HEAD'}
-        when 19 then {':method' => 'OPTIONS'}
-        when 20 then {':method' => 'POST'}
-        when 21 then {':method' => 'PUT'}
-        when 22 then {':scheme' => 'http'}
-        when 23 then {':scheme' => 'https'}
-        else nil
+        return nil if index >= HTTP3::STATIC_TABLE.size
+
+        name, value = HTTP3::STATIC_TABLE[index]
+
+        # If value is empty, return just the name (caller provides value)
+        # Otherwise return complete field as hash
+        if value.empty?
+          name
+        else
+          {name => value}
         end
       end
     end