http-2 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96271a021aa473e7c555c6ceca6509f30e4ad457051e3971304c5a841afe4ca6
-  data.tar.gz: 5f2284ff6211f414291337d4efe260fc52bb9e18ccdb8bf19408ae781469994c
+  metadata.gz: b5f246529e7f64c9b6c841e7733a8bcc74ce34452fa0569c48bf1a858d47d659
+  data.tar.gz: ae38ca8cb1814c168fa2e90f729b12b0a3017a41d35406472dfe425308adb107
 SHA512:
-  metadata.gz: 6a3f9b4f1a98f232405b85559c91d976c0712defe2cfe1e1ef4468bc81b7e278abd162f3e0de8828dddcdfaff11808a0cab7c794353f5224303eb8b00a4b44ec
-  data.tar.gz: e14c1ec4652af944dfa791dacae8af519982c04b652b9ef352a1aa2377a15c80f829a2654da7c6e556680d522c7405137e4e5ab24dcb68e196eeb41e5ad54a18
+  metadata.gz: 5cc781007b5fa286344fb6ebc1495b4caaddc5c25749ae1ab6fb938f18f17ac50624bbf0160cb3e6661b91d1290ea350a550696e6ed28db20f6bb34c0ca0b6c7
+  data.tar.gz: 2bbcd46df4b28f59f7b64c68338998bae8d5199ee71942704ae32fb8e643c328b888b2579db4d8bf1b8ed220e76ea1bc27d9ef14ecc5ad21c05cb35252f2e4d1

data/lib/http/2/client.rb

@@ -26,6 +26,7 @@ module HTTP2
 
       @local_role   = :client
       @remote_role  = :server
+      @h2c_upgrade = nil
 
       super
     end

data/lib/http/2/connection.rb

@@ -36,9 +36,14 @@ module HTTP2
   CONNECTION_PREFACE_MAGIC = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
 
   REQUEST_MANDATORY_HEADERS = %w[:scheme :method :authority :path].freeze
+
   RESPONSE_MANDATORY_HEADERS = %w[:status].freeze
 
-  EMPTY = [].freeze
+  CONNECTION_FRAME_TYPES = %i[settings ping goaway].freeze
+
+  HEADERS_FRAME_TYPES = %i[headers push_promise].freeze
+
+  STREAM_OPEN_STATES = %i[open half_closed_local].freeze
 
   # Connection encapsulates all of the connection, stream, flow-control,
   # error management, and other processing logic required for a well-behaved
@@ -47,13 +52,11 @@ module HTTP2
   # Note that this class should not be used directly. Instead, you want to
   # use either Client or Server class to drive the HTTP 2.0 exchange.
   #
-  # rubocop:disable Metrics/ClassLength
   class Connection
     include FlowBuffer
     include Emitter
     include Error
-
-    using StringExtensions
+    include BufferUtils
 
     # Connection state (:new, :closed).
     attr_reader :state
@@ -85,7 +88,6 @@ module HTTP2
       @decompressor = Header::Decompressor.new(settings)
 
       @active_stream_count = 0
-      @last_activated_stream = 0
       @last_stream_id = 0
       @streams = {}
       @streams_recently_closed = {}
@@ -105,6 +107,10 @@ module HTTP2
       @h2c_upgrade = nil
       @closed_since = nil
       @received_frame = false
+
+      # from mixins
+      @listeners = Hash.new { |hash, key| hash[key] = [] }
+      @send_buffer = FrameBuffer.new
     end
 
     def closed?
@@ -120,10 +126,10 @@ module HTTP2
       raise ConnectionClosed if @state == :closed
       raise StreamLimitExceeded if @active_stream_count >= @remote_settings[:settings_max_concurrent_streams]
 
-      connection_error(:protocol_error, msg: "id is smaller than previous") if @stream_id < @last_activated_stream
+      connection_error(:protocol_error, msg: "id is smaller than previous") if @stream_id < @last_stream_id
 
       stream = activate_stream(id: @stream_id, **args)
-      @last_activated_stream = stream.id
+      @last_stream_id = stream.id
 
       @stream_id += 2
 
@@ -150,13 +156,7 @@ module HTTP2
     # @param error [Symbol]
     # @param payload [String]
     def goaway(error = :no_error, payload = nil)
-      last_stream = if (max = @streams.max)
-                      max.first
-                    else
-                      0
-                    end
-
-      send(type: :goaway, last_stream: last_stream,
+      send(type: :goaway, last_stream: @last_stream_id,
            error: error, payload: payload)
       @state = :closed
       @closed_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -175,7 +175,6 @@ module HTTP2
     #
     # @param settings [Array or Hash]
     def settings(payload)
-      payload = payload.to_a
       validate_settings(@local_role, payload)
       @pending_settings << payload
       send(type: :settings, stream: 0, payload: payload)
@@ -188,7 +187,7 @@ module HTTP2
     #
     # @param data [String] Binary encoded string
     def receive(data)
-      @recv_buffer << data
+      append_str(@recv_buffer, data)
 
       # Upon establishment of a TCP connection and determination that
       # HTTP/2.0 will be used by both peers, each endpoint MUST send a
@@ -202,7 +201,7 @@ module HTTP2
           raise HandshakeError unless CONNECTION_PREFACE_MAGIC.start_with? @recv_buffer
 
           return # maybe next time
-        elsif @recv_buffer.read(24) == CONNECTION_PREFACE_MAGIC
+        elsif read_str(@recv_buffer, 24) == CONNECTION_PREFACE_MAGIC
           # MAGIC is OK.  Send our settings
           @state = :waiting_connection_preface
           payload = @local_settings.reject { |k, v| v == SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
@@ -213,14 +212,18 @@ module HTTP2
       end
 
       while (frame = @framer.parse(@recv_buffer))
+        # @type var stream_id: Integer
+        stream_id = frame[:stream]
+        frame_type = frame[:type]
+
         if is_a?(Client) && !@received_frame
-          connection_error(:protocol_error, msg: "didn't receive settings") if frame[:type] != :settings
+          connection_error(:protocol_error, msg: "didn't receive settings") if frame_type != :settings
           @received_frame = true
         end
 
         # Implementations MUST discard frames
         # that have unknown or unsupported types.
-        if frame[:type].nil?
+        if frame_type.nil?
           # However, extension frames that appear in
           # the middle of a header block (Section 4.3) are not permitted; these
           # MUST be treated as a connection error (Section 5.4.1) of type
@@ -234,7 +237,7 @@ module HTTP2
         # Header blocks MUST be transmitted as a contiguous sequence of frames
         # with no interleaved frames of any other type, or from any other stream.
         unless @continuation.empty?
-          connection_error unless frame[:type] == :continuation && frame[:stream] == @continuation.first[:stream]
+          connection_error unless frame_type == :continuation && stream_id == @continuation.first[:stream]
 
           @continuation << frame
           unless frame[:flags].include? :end_headers
@@ -253,6 +256,8 @@ module HTTP2
           payload = @continuation.map { |f| f[:payload] }.join
 
           frame = @continuation.shift
+          frame_type = frame[:type]
+
           @continuation.clear
 
           frame.delete(:length)
@@ -266,14 +271,14 @@ module HTTP2
         # anything other than 0x0, the endpoint MUST respond with a connection
         # error (Section 5.4.1) of type PROTOCOL_ERROR.
         if connection_frame?(frame)
-          connection_error(:protocol_error) unless frame[:stream].zero?
+          connection_error(:protocol_error) unless stream_id.zero?
           connection_management(frame)
         else
-          case frame[:type]
+          case frame_type
           when :headers
             # When server receives even-numbered stream identifier,
             # the endpoint MUST respond with a connection error of type PROTOCOL_ERROR.
-            connection_error if frame[:stream].even? && is_a?(Server)
+            connection_error if stream_id.even? && is_a?(Server)
 
             # The last frame in a sequence of HEADERS/CONTINUATION
             # frames MUST have the END_HEADERS flag set.
@@ -290,13 +295,13 @@ module HTTP2
             decode_headers(frame)
             return if @state == :closed
 
-            stream = @streams[frame[:stream]]
+            stream = @streams[stream_id]
             if stream.nil?
               verify_pseudo_headers(frame)
 
-              verify_stream_order(frame[:stream])
+              verify_stream_order(stream_id)
               stream = activate_stream(
-                id: frame[:stream],
+                id: stream_id,
                 weight: frame[:weight] || DEFAULT_WEIGHT,
                 dependency: frame[:dependency] || 0,
                 exclusive: frame[:exclusive] || false
@@ -327,18 +332,18 @@ module HTTP2
             # that is not currently in the "idle" state) as a connection error
             # (Section 5.4.1) of type PROTOCOL_ERROR, unless the receiver
             # recently sent a RST_STREAM frame to cancel the associated stream.
-            parent = @streams[frame[:stream]]
+            parent = @streams[stream_id]
             pid = frame[:promise_stream]
 
             # if PUSH parent is recently closed, RST_STREAM the push
-            if @streams_recently_closed[frame[:stream]]
+            if @streams_recently_closed[stream_id]
               send(type: :rst_stream, stream: pid, error: :refused_stream)
               return
             end
 
             connection_error(msg: "missing parent ID") if parent.nil?
 
-            unless parent.state == :open || parent.state == :half_closed_local
+            unless STREAM_OPEN_STATES.include?(parent.state)
               # An endpoint might receive a PUSH_PROMISE frame after it sends
               # RST_STREAM.  PUSH_PROMISE causes a stream to become "reserved".
               # The RST_STREAM does not cancel any promised stream.  Therefore, if
@@ -359,21 +364,21 @@ module HTTP2
             emit(:promise, stream)
             stream << frame
           else
-            if (stream = @streams[frame[:stream]])
+            if (stream = @streams[stream_id])
               stream << frame
-              if frame[:type] == :data
+              if frame_type == :data
                 update_local_window(frame)
                 calculate_window_update(@local_window_limit)
               end
             else
-              case frame[:type]
+              case frame_type
               # The PRIORITY frame can be sent for a stream in the "idle" or
               # "closed" state. This allows for the reprioritization of a
               # group of dependent streams by altering the priority of an
               # unused or closed parent stream.
               when :priority
                 stream = activate_stream(
-                  id: frame[:stream],
+                  id: stream_id,
                   weight: frame[:weight] || DEFAULT_WEIGHT,
                   dependency: frame[:dependency] || 0,
                   exclusive: frame[:exclusive] || false
@@ -388,15 +393,17 @@ module HTTP2
               # "closed" stream. A receiver MUST NOT treat this as an error
               # (see Section 5.1).
               when :window_update
-                stream = @streams_recently_closed[frame[:stream]]
-                connection_error(:protocol_error, msg: "sent window update on idle stream") unless stream
+                unless @streams_recently_closed.key?(stream_id)
+                  connection_error(:protocol_error, msg: "sent window update on idle stream")
+                end
+                stream = @streams_recently_closed[stream_id]
                 process_window_update(frame: frame, encode: true)
               # Endpoints MUST ignore
               # WINDOW_UPDATE or RST_STREAM frames received in this state (closed), though
               # endpoints MAY choose to treat frames that arrive a significant
               # time after sending END_STREAM as a connection error.
               when :rst_stream
-                stream = @streams_recently_closed[frame[:stream]]
+                stream = @streams_recently_closed[stream_id]
                 connection_error(:protocol_error, msg: "sent window update on idle stream") unless stream
               else
                 # An endpoint that receives an unexpected stream identifier
@@ -426,35 +433,33 @@ module HTTP2
     # @note all frames are currently delivered in FIFO order.
     # @param frame [Hash]
     def send(frame)
+      frame_type = frame[:type]
+
       emit(:frame_sent, frame)
-      if frame[:type] == :data
+      if frame_type == :data
         send_data(frame, true)
 
-      elsif frame[:type] == :rst_stream && frame[:error] == :protocol_error
+      elsif frame_type == :rst_stream && frame[:error] == :protocol_error
         # An endpoint can end a connection at any time. In particular, an
         # endpoint MAY choose to treat a stream error as a connection error.
 
-        goaway(frame[:error])
+        goaway(:protocol_error)
       else
         # HEADERS and PUSH_PROMISE may generate CONTINUATION. Also send
         # RST_STREAM that are not protocol errors
-        frames = encode(frame)
-        frames.each { |f| emit(:frame, f) }
+        encode(frame)
       end
     end
 
     # Applies HTTP 2.0 binary encoding to the frame.
     #
     # @param frame [Hash]
-    # @return [Array of Buffer] encoded frame
     def encode(frame)
-      frames = if frame[:type] == :headers || frame[:type] == :push_promise
-                 encode_headers(frame) # HEADERS and PUSH_PROMISE may create more than one frame
-               else
-                 [frame] # otherwise one frame
-               end
-
-      frames.map { |f| @framer.generate(f) }
+      if HEADERS_FRAME_TYPES.include?(frame[:type])
+        encode_headers(frame) # HEADERS and PUSH_PROMISE may create more than one frame
+      else
+        emit(:frame, @framer.generate(frame))
+      end
     end
 
     # Check if frame is a connection frame: SETTINGS, PING, GOAWAY, and any
@@ -463,10 +468,7 @@ module HTTP2
     # @param frame [Hash]
     # @return [Boolean]
     def connection_frame?(frame)
-      (frame[:stream]).zero? ||
-        frame[:type] == :settings ||
-        frame[:type] == :ping ||
-        frame[:type] == :goaway
+      frame[:stream].zero? || CONNECTION_FRAME_TYPES.include?(frame[:type])
     end
 
     # Process received connection frame (stream ID = 0).
@@ -477,14 +479,18 @@ module HTTP2
     #
     # @param frame [Hash]
     def connection_management(frame)
+      frame_type = frame[:type]
+
       case @state
       when :waiting_connection_preface
         # The first frame MUST be a SETTINGS frame at the start of a connection.
+        connection_error unless frame[:type] == :settings
+
         @state = :connected
         connection_settings(frame)
 
       when :connected
-        case frame[:type]
+        case frame_type
         when :settings
           connection_settings(frame)
         when :window_update
@@ -499,23 +505,24 @@ module HTTP2
           @closed_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           emit(:goaway, frame[:last_stream], frame[:error], frame[:payload])
         when :altsvc
+          origin = frame[:origin]
           # 4.  The ALTSVC HTTP/2 Frame
           # An ALTSVC frame on stream 0 with empty (length 0) "Origin"
           # information is invalid and MUST be ignored.
-          emit(frame[:type], frame) if frame[:origin] && !frame[:origin].empty?
+          emit(:altsvc, frame) if origin && !origin.empty?
         when :origin
           return if @h2c_upgrade || !frame[:flags].empty?
 
-          frame[:payload].each do |origin|
-            emit(frame[:type], origin)
+          frame[:payload].each do |orig|
+            emit(:origin, orig)
           end
         when :blocked
-          emit(frame[:type], frame)
+          emit(:blocked, frame)
         else
           connection_error
         end
       when :closed
-        case frame[:type]
+        case frame_type
         when :goaway
           connection_error
         when :ping
@@ -574,7 +581,7 @@ module HTTP2
           # allowed frame size (2^24-1 or 16,777,215 octets), inclusive.
           # Values outside this range MUST be treated as a connection error
           # (Section 5.4.1) of type PROTOCOL_ERROR.
-          next if v >= 16_384 && v <= 16_777_215
+          next if v.between?(16_384, 16_777_215)
 
           connection_error(:protocol_error, msg: "invalid #{key} value")
           # when :settings_max_concurrent_streams
@@ -592,19 +599,19 @@ module HTTP2
     #
     # @param frame [Hash]
     def connection_settings(frame)
-      connection_error unless frame[:type] == :settings && (frame[:stream]).zero?
-
       # Apply settings.
       #  side =
       #   local: previously sent and pended our settings should be effective
       #   remote: just received peer settings should immediately be effective
-      settings, side = if frame[:flags].include?(:ack)
-                         # Process pending settings we have sent.
-                         [@pending_settings.shift, :local]
-                       else
-                         validate_settings(@remote_role, frame[:payload])
-                         [frame[:payload], :remote]
-                       end
+      if frame[:flags].include?(:ack)
+        # Process pending settings we have sent.
+        settings = @pending_settings.shift
+        side = :local
+      else
+        validate_settings(@remote_role, frame[:payload])
+        settings = frame[:payload]
+        side = :remote
+      end
 
       settings.each do |key, v|
         case side
@@ -700,40 +707,48 @@ module HTTP2
 
     # Encode headers payload and update connection compressor state.
     #
-    # @param frame [Hash]
-    # @return [Array of Frame]
-    def encode_headers(frame)
-      payload = frame[:payload]
+    # @param headers_frame [Hash]
+    def encode_headers(headers_frame)
+      payload = headers_frame[:payload]
       begin
-        payload = frame[:payload] = @compressor.encode(payload) unless payload.is_a?(String)
+        payload = headers_frame[:payload] = @compressor.encode(payload) unless payload.is_a?(String)
       rescue StandardError => e
         connection_error(:compression_error, e: e)
       end
 
-      # if single frame, return immediately
-      return [frame] if payload.bytesize <= @remote_settings[:settings_max_frame_size]
+      max_frame_size = @remote_settings[:settings_max_frame_size]
 
-      frames = []
+      # if single frame, return immediately
+      if payload.bytesize <= max_frame_size
+        emit(:frame, @framer.generate(headers_frame))
+        return
+      end
 
-      until payload.nil? || payload.empty?
-        cont = frame.dup
+      # split into multiple CONTINUATION frames
+      headers_frame[:flags].delete(:end_headers)
+      headers_frame[:payload] = payload.byteslice(0, max_frame_size)
+      payload = payload.byteslice(max_frame_size..-1)
 
-        # first frame remains HEADERS
-        unless frames.empty?
-          cont[:type] = :continuation
-          cont[:flags] = EMPTY
-        end
+      # emit first HEADERS frame
+      emit(:frame, @framer.generate(headers_frame))
 
-        cont[:payload] = payload.byteslice(0, @remote_settings[:settings_max_frame_size])
-        payload = payload.byteslice(@remote_settings[:settings_max_frame_size]..-1)
+      loop do
+        continuation_frame = headers_frame.merge(
+          type: :continuation,
+          flags: EMPTY,
+          payload: payload.byteslice(0, max_frame_size)
+        )
 
-        frames << cont
-      end
+        payload = payload.byteslice(max_frame_size..-1)
 
-      frames.first[:flags].delete(:end_headers)
-      frames.last[:flags] = [:end_headers]
+        if payload.nil? || payload.empty?
+          continuation_frame[:flags] = [:end_headers]
+          emit(:frame, @framer.generate(continuation_frame))
+          break
+        end
 
-      frames
+        emit(:frame, @framer.generate(continuation_frame))
+      end
     end
 
     # Activates new incoming or outgoing stream and registers appropriate
@@ -759,17 +774,22 @@ module HTTP2
         # is closed, with a minimum of 15s RTT time window.
         now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-        # TODO: use a drop_while! variant whenever there is one.
-        @streams_recently_closed = @streams_recently_closed.drop_while do |_, v|
-          (now - v) > 15
-        end.to_h
+        _, closed_since = @streams_recently_closed.first
+
+        # forego recently closed recycling if empty or the first element
+        # hasn't expired yet (it's ordered).
+        if closed_since && (now - closed_since) > 15
+          # discards all streams which have closed for a while.
+          # TODO: use a drop_while! variant whenever there is one.
+          @streams_recently_closed = @streams_recently_closed.drop_while do |_, since|
+            (now - since) > 15
+          end.to_h
+        end
 
         @streams_recently_closed[id] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
 
-      stream.on(:promise, &method(:promise)) if is_a? Server
-      stream.on(:frame,   &method(:send))
-
+      stream.on(:frame, &method(:send))
       @streams[id] = stream
     end
 
@@ -821,5 +841,4 @@ module HTTP2
       yield
     end
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/lib/http/2/emitter.rb

@@ -12,7 +12,7 @@ module HTTP2
     def on(event, &block)
       raise ArgumentError, "must provide callback" unless block
 
-      listeners(event.to_sym).push block
+      @listeners[event] << block
     end
 
     # Subscribe to next event (at most once) for specified type.
@@ -32,16 +32,9 @@ module HTTP2
     # @param args [Array] arguments to be passed to the callbacks
     # @param block [Proc] callback function
     def emit(event, *args, &block)
-      listeners(event).delete_if do |cb|
+      @listeners[event].delete_if do |cb|
         :delete == cb.call(*args, &block) # rubocop:disable Style/YodaCondition
       end
     end
-
-    private
-
-    def listeners(event)
-      @listeners ||= Hash.new { |hash, key| hash[key] = [] }
-      @listeners[event]
-    end
   end
 end

data/lib/http/2/extensions.rb

@@ -1,24 +1,42 @@
 # frozen_string_literal: true
 
 module HTTP2
-  module StringExtensions
-    refine String do
-      def read(n)
-        return "".b if n == 0
-
-        chunk = byteslice(0..n - 1)
-        remaining = byteslice(n..-1)
-        remaining ? replace(remaining) : clear
-        chunk
+  module BufferUtils
+    if RUBY_VERSION > "3.4.0"
+      def append_str(str, data)
+        str.append_as_bytes(data)
       end
+    else
+      def append_str(str, data)
+        enc = data.encoding
+        reset = false
 
-      def read_uint32
-        read(4).unpack1("N")
+        if enc != Encoding::BINARY
+          reset = true
+          data = data.dup if data.frozen?
+          data.force_encoding(Encoding::BINARY)
+        end
+        str << data
+      ensure
+        data.force_encoding(enc) if reset
       end
+    end
 
-      def shift_byte
-        read(1).ord
-      end
+    def read_str(str, n)
+      return "".b if n == 0
+
+      chunk = str.byteslice(0..n - 1)
+      remaining = str.byteslice(n..-1)
+      remaining ? str.replace(remaining) : str.clear
+      chunk
+    end
+
+    def read_uint32(str)
+      read_str(str, 4).unpack1("N")
+    end
+
+    def shift_byte(str)
+      read_str(str, 1).ord
     end
   end
 
@@ -30,7 +48,7 @@ module HTTP2
         packed_str = array_to_pack.pack(template)
         case offset
         when -1
-          buffer << packed_str
+          append_str(buffer, packed_str)
         when 0
           buffer.prepend(packed_str)
         else