http-2 0.11.0 → 1.0.0

data/lib/http/2/emitter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HTTP2
   # Basic event emitter implementation with support for persistent and
   # one-time event callbacks.
@@ -7,18 +9,18 @@ module HTTP2
     #
     # @param event [Symbol]
     # @param block [Proc] callback function
-    def add_listener(event, &block)
-      fail ArgumentError, 'must provide callback' unless block_given?
+    def on(event, &block)
+      raise ArgumentError, "must provide callback" unless block
+
       listeners(event.to_sym).push block
     end
-    alias on add_listener
 
     # Subscribe to next event (at most once) for specified type.
     #
     # @param event [Symbol]
     # @param block [Proc] callback function
     def once(event, &block)
-      add_listener(event) do |*args, &callback|
+      on(event) do |*args, &callback|
         block.call(*args, &callback)
         :delete
       end
@@ -31,7 +33,7 @@ module HTTP2
     # @param block [Proc] callback function
     def emit(event, *args, &block)
       listeners(event).delete_if do |cb|
-        cb.call(*args, &block) == :delete
+        :delete == cb.call(*args, &block) # rubocop:disable Style/YodaCondition
       end
     end
 

data/lib/http/2/error.rb

@@ -1,7 +1,26 @@
+# frozen_string_literal: true
+
 module HTTP2
   # Stream, connection, and compressor exceptions.
   module Error
-    class Error < StandardError; end
+    @types = {}
+
+    class << self
+      attr_reader :types
+    end
+
+    class Error < StandardError
+      def self.inherited(klass)
+        super
+
+        type = klass.name or return
+
+        type = type.split("::").last or return
+
+        type = type.gsub(/([^\^])([A-Z])/, '\1_\2').downcase.to_sym
+        HTTP2::Error.types[type] = klass
+      end
+    end
 
     # Raised if connection header is missing or invalid indicating that
     # this is an invalid HTTP 2.0 request - no frames are emitted and the
@@ -40,5 +59,9 @@ module HTTP2
 
     # Raised if stream limit has been reached and new stream cannot be opened.
     class StreamLimitExceeded < Error; end
+
+    class FrameSizeError < Error; end
+
+    @types.freeze
   end
 end

data/lib/http/2/extensions.rb

@@ -0,0 +1,53 @@
+# 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
+      end
+
+      def read_uint32
+        read(4).unpack1("N")
+      end
+
+      def shift_byte
+        read(1).ord
+      end
+    end
+  end
+
+  # this mixin handles backwards-compatibility for the new packing options
+  # shipping with ruby 3.3 (see https://docs.ruby-lang.org/en/3.3/packed_data_rdoc.html)
+  module PackingExtensions
+    if RUBY_VERSION < "3.3.0"
+      def pack(array_to_pack, template, buffer:, offset: -1)
+        packed_str = array_to_pack.pack(template)
+        case offset
+        when -1
+          buffer << packed_str
+        when 0
+          buffer.prepend(packed_str)
+        else
+          buffer.insert(offset, packed_str)
+        end
+      end
+    else
+      def pack(array_to_pack, template, buffer:, offset: -1)
+        case offset
+        when -1
+          array_to_pack.pack(template, buffer: buffer)
+        when 0
+          buffer.prepend(array_to_pack.pack(template))
+        else
+          buffer.insert(offset, array_to_pack.pack(template))
+        end
+      end
+    end
+  end
+end

data/lib/http/2/flow_buffer.rb

@@ -1,18 +1,32 @@
+# frozen_string_literal: true
+
 module HTTP2
   # Implementation of stream and connection DATA flow control: frames may
   # be split and / or may be buffered based on current flow control window.
   #
   module FlowBuffer
+    include Error
+
+    MAX_WINDOW_SIZE = (2 << 30) - 1
+
     # Amount of buffered data. Only DATA payloads are subject to flow stream
     # and connection flow control.
     #
     # @return [Integer]
     def buffered_amount
-      @send_buffer.map { |f| f[:length] }.reduce(:+) || 0
+      send_buffer.bytesize
+    end
+
+    def flush
+      send_data
     end
 
     private
 
+    def send_buffer
+      @send_buffer ||= FrameBuffer.new
+    end
+
     def update_local_window(frame)
       frame_size = frame[:payload].bytesize
       frame_size += frame[:padding] || 0
@@ -41,6 +55,7 @@ module HTTP2
       # until the receiver window is exhausted, after which he'll be
       # waiting for the WINDOW_UPDATE frame.
       return unless @local_window <= (window_max_size / 2)
+
       window_update(window_max_size - @local_window)
     end
 
@@ -52,49 +67,92 @@ module HTTP2
     # Buffered DATA frames are emitted in FIFO order.
     #
     # @param frame [Hash]
-    # @param encode [Boolean] set to true by co
+    # @param encode [Boolean] set to true by connection
     def send_data(frame = nil, encode = false)
-      @send_buffer.push frame unless frame.nil?
+      send_buffer << frame unless frame.nil?
 
-      # FIXME: Frames with zero length with the END_STREAM flag set (that
-      # is, an empty DATA frame) MAY be sent if there is no available space
-      # in either flow control window.
-      while @remote_window > 0 && !@send_buffer.empty?
-        frame = @send_buffer.shift
+      while (frame = send_buffer.retrieve(@remote_window))
 
-        sent, frame_size = 0, frame[:payload].bytesize
-
-        if frame_size > @remote_window
-          payload = frame.delete(:payload)
-          chunk   = frame.dup
-
-          # Split frame so that it fits in the window
-          # TODO: consider padding!
-          frame[:payload] = payload.slice!(0, @remote_window)
-          chunk[:length]  = payload.bytesize
-          chunk[:payload] = payload
-
-          # if no longer last frame in sequence...
-          frame[:flags] -= [:end_stream] if frame[:flags].include? :end_stream
-
-          @send_buffer.unshift chunk
-          sent = @remote_window
-        else
-          sent = frame_size
-        end
+        # puts "#{self.class} -> #{@remote_window}"
+        sent = frame[:payload].bytesize
 
         manage_state(frame) do
-          frames = encode ? encode(frame) : [frame]
-          frames.each { |f| emit(:frame, f) }
+          if encode
+            encode(frame).each { |f| emit(:frame, f) }
+          else
+            emit(:frame, frame)
+          end
           @remote_window -= sent
         end
       end
     end
 
-    def process_window_update(frame)
+    def process_window_update(frame:, encode: false)
       return if frame[:ignore]
-      @remote_window += frame[:increment]
-      send_data
+
+      if frame[:increment]
+        raise ProtocolError, "increment MUST be higher than zero" if frame[:increment].zero?
+
+        @remote_window += frame[:increment]
+        error(:flow_control_error, msg: "window size too large") if @remote_window > MAX_WINDOW_SIZE
+      end
+      send_data(nil, encode)
+    end
+  end
+
+  class FrameBuffer
+    attr_reader :bytesize
+
+    def initialize
+      @buffer = []
+      @bytesize = 0
+    end
+
+    def <<(frame)
+      @buffer << frame
+      @bytesize += frame[:payload].bytesize
+    end
+
+    def empty?
+      @bytesize.zero?
+    end
+
+    def retrieve(window_size)
+      frame = @buffer.first or return
+
+      frame_size = frame[:payload].bytesize
+      end_stream = frame[:flags].include? :end_stream
+
+      # Frames with zero length with the END_STREAM flag set (that
+      # is, an empty DATA frame) MAY be sent if there is no available space
+      # in either flow control window.
+      return if window_size <= 0 && !(frame_size == 0 && end_stream)
+
+      @buffer.shift
+
+      if frame_size > window_size
+        payload = frame[:payload]
+        chunk   = frame.dup
+
+        # Split frame so that it fits in the window
+        # TODO: consider padding!
+        frame_bytes = payload.byteslice(0, window_size)
+        payload = payload.byteslice(window_size..-1)
+
+        frame[:payload] = frame_bytes
+        frame[:length] = frame_bytes.bytesize
+        chunk[:payload] = payload
+        chunk[:length]  = payload.bytesize
+
+        # if no longer last frame in sequence...
+        frame[:flags] -= [:end_stream] if end_stream
+
+        @buffer.unshift(chunk)
+        @bytesize -= window_size
+      else
+        @bytesize -= frame_size
+      end
+      frame
     end
   end
 end