quicsilver 0.2.0 → 0.4.0

data/lib/quicsilver/client.rb

@@ -1,261 +0,0 @@
-# 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.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 AlreadyConnectedError if @connected
-
-      Quicsilver.open_connection
-      
-      config = Quicsilver.create_configuration(@unsecure)
-      raise ConnectionError, "Failed to create configuration" if config.nil?
-
-      # Create connection (returns [handle, context])
-      # 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, context_handle = @connection_data
-
-      # Start the connection
-      success = Quicsilver.start_connection(connection_handle, config, @hostname, @port)
-      unless success
-        Quicsilver.close_configuration(config)
-        cleanup_failed_connection
-        raise ConnectionError, "Failed to start connection"
-      end
-
-      result = Quicsilver.wait_for_connection(context_handle, @connection_timeout)
-      handle_connection_result(result, config)
-      
-      @connected = true
-      @connection_start_time = Time.now
-
-      send_control_stream
-      Quicsilver.close_configuration(config) # Clean up config since connection is established
-
-      Quicsilver.event_loop.start
-      self
-    rescue => e
-      cleanup_failed_connection
-      
-      if e.is_a?(ConnectionError) || e.is_a?(TimeoutError)
-        raise e
-      else
-        raise ConnectionError, "Connection failed: #{e.message}"
-      end
-    end
-    
-    def disconnect
-      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 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
-
-      # 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
-
-      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
-      info = @connection_data ? Quicsilver.connection_status(@connection_data[1]) : {}
-      info.merge(hostname: @hostname, port: @port, uptime: connection_uptime)
-    end
-    
-    def connection_uptime
-      return 0 unless @connection_start_time
-      Time.now - @connection_start_time
-    end
-
-    def authority
-      "#{@hostname}:#{@port}"
-    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
-
-          # 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
-      Quicsilver.logger.error("Error handling client stream: #{e.class} - #{e.message}")
-      Quicsilver.logger.debug(e.backtrace.first(5).join("\n"))
-    end
-    
-    private
-    
-    def cleanup_failed_connection
-      Quicsilver.close_connection_handle(@connection_data) if @connection_data
-      @connection_data = nil
-      @connected = false
-    end
-
-    def open_stream
-      Quicsilver.open_stream(@connection_data, false)
-    end
-
-    def open_unidirectional_stream
-      Quicsilver.open_stream(@connection_data, true)
-    end
-
-    def send_control_stream
-      # Open unidirectional stream
-      stream = open_unidirectional_stream
-
-      # Build and send control stream data
-      control_data = Quicsilver::HTTP3.build_control_stream
-      Quicsilver.send_stream(stream, control_data, false)
-
-      @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

@@ -1,42 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-# 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

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Quicsilver
-  module HTTP3
-    class RequestEncoder
-      def initialize(method:, path:, scheme: 'https', authority: 'localhost:4433', headers: {}, body: nil)
-        @method = method.upcase
-        @path = path
-        @scheme = scheme
-        @authority = authority
-        @headers = headers
-        @body = body
-      end
-
-      def encode
-        frames = []
-
-        # Build HEADERS frame
-        headers_payload = encode_headers
-        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(HTTP3::FRAME_DATA, body_data)
-        end
-
-        frames.join.force_encoding(Encoding::BINARY)
-      end
-
-      private
-
-      def build_frame(type, payload)
-        frame_type = HTTP3.encode_varint(type)
-        frame_length = HTTP3.encode_varint(payload.bytesize)
-        frame_type + frame_length + payload
-      end
-
-      def encode_headers
-        payload = "".b
-
-        # QPACK prefix: Required Insert Count = 0, Delta Base = 0
-        payload += "\x00\x00".b
-
-        # Encode pseudo-headers using Indexed Field Line with Post-Base Index
-        # Pattern: 0x50 (0101 0000) for :method, :scheme
-        # Pattern: 0x40 | index for :authority, :path (literal name, literal value)
-
-        # :method (use literal since GET/POST have specific indices but we want flexibility)
-        payload += encode_literal_pseudo_header(':method', @method)
-
-        # :scheme
-        payload += encode_literal_pseudo_header(':scheme', @scheme)
-
-        # :authority
-        payload += encode_literal_pseudo_header(':authority', @authority)
-
-        # :path
-        payload += encode_literal_pseudo_header(':path', @path)
-
-        # Encode regular headers
-        @headers.each do |name, value|
-          payload += encode_literal_header(name.to_s.downcase, value.to_s)
-        end
-
-        payload
-      end
-
-      # Literal field line with literal name for pseudo-headers
-      # Pattern: 0x50 (indexed name from static table) + value
-      def encode_literal_pseudo_header(name, value)
-        result = "".b
-
-        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.b
-          end
-
-        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
-          return encode_literal_header(name, value)
-        end
-
-        result
-      end
-
-      # Literal field line with literal name
-      # Pattern: 0x20 | name_length, name_bytes, value_length, value_bytes
-      def encode_literal_header(name, value)
-        result = "".b
-        # 0x20 = literal with literal name (no indexing)
-        name_len = name.bytesize
-        result += [0x20 | (name_len & 0x1F)].pack('C')
-        result += name.b
-        result += HTTP3.encode_varint(value.bytesize)
-        result += value.to_s.b
-        result
-      end
-    end
-  end
-end

data/lib/quicsilver/http3/request_parser.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-
-module Quicsilver
-  module HTTP3
-    class RequestParser
-      attr_reader :frames, :headers, :body
-
-      def initialize(data)
-        @data = data
-        @frames = []
-        @headers = {}
-        @body = StringIO.new
-        @body.set_encoding(Encoding::ASCII_8BIT)
-      end
-
-      def parse
-        parse!
-      end
-
-      def to_rack_env(stream_info = {})
-        return nil if @headers.empty?
-
-        # Extract path and query string
-        path_full = @headers[':path'] || '/'
-        path, query = path_full.split('?', 2)
-
-        # Extract host and port
-        authority = @headers[':authority'] || 'localhost:4433'
-        host, port = authority.split(':', 2)
-        port ||= '4433'
-
-        env = {
-          'REQUEST_METHOD' => @headers[':method'] || 'GET',
-          'PATH_INFO' => path,
-          'QUERY_STRING' => query || '',
-          'SERVER_NAME' => host,
-          'SERVER_PORT' => port,
-          'SERVER_PROTOCOL' => 'HTTP/3',
-          'rack.version' => [1, 3],
-          'rack.url_scheme' => @headers[':scheme'] || 'https',
-          'rack.input' => @body,
-          'rack.errors' => $stderr,
-          'rack.multithread' => true,
-          'rack.multiprocess' => false,
-          'rack.run_once' => false,
-          'rack.hijack?' => false,
-          'SCRIPT_NAME' => '',
-          'CONTENT_LENGTH' => @body.size.to_s,
-        }
-
-        # 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?(':')
-          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
-      end
-
-      private
-
-      def parse!
-        buffer = @data.dup
-        offset = 0
-
-        while offset < buffer.bytesize
-          break if buffer.bytesize - offset < 2
-
-          type, type_len = HTTP3.decode_varint(buffer.bytes, offset)
-          length, length_len = HTTP3.decode_varint(buffer.bytes, offset + type_len)
-          header_len = type_len + length_len
-
-          break if buffer.bytesize < offset + header_len + length
-
-          payload = buffer[offset + header_len, length]
-          @frames << { type: type, length: length, payload: payload }
-
-          case type
-          when 0x01 # HEADERS
-            parse_headers(payload)
-          when 0x00 # DATA
-            @body.write(payload)
-          end
-
-          offset += header_len + length
-        end
-
-        @body.rewind
-      end
-
-      def parse_headers(payload)
-        # Skip QPACK required insert count (1 byte) + delta base (1 byte)
-        offset = 2
-        return if payload.bytesize < offset
-
-        while offset < payload.bytesize
-          byte = payload.bytes[offset]
-
-          # Pattern 1: Indexed Field Line (1Txxxxxx)
-          # Use both name AND value from static table
-          if (byte & 0x80) == 0x80
-            index = byte & 0x3F
-            offset += 1
-
-            field = decode_static_table_field(index)
-            if field.is_a?(Hash)
-              @headers.merge!(field)
-            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[name] = value
-            end
-          # Pattern 5: Literal with literal name (001NHxxx)
-          elsif (byte & 0xE0) == 0x20
-            name_len = byte & 0x1F
-            offset += 1
-            name = payload[offset, name_len]
-            offset += name_len
-
-            value_len, len_bytes = HTTP3.decode_varint(payload.bytes, offset)
-            offset += len_bytes
-            value = payload[offset, value_len]
-            offset += value_len
-
-            @headers[name] = value
-          else
-            break # Unknown encoding
-          end
-        end
-      end
-
-      # QPACK static table decoder (RFC 9204 Appendix A)
-      # Returns Hash for complete fields, String for name-only fields
-      def decode_static_table_field(index)
-        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
-  end
-end