http-2 1.0.2 → 1.1.1

data/lib/http/2/stream.rb

@@ -40,6 +40,8 @@ module HTTP2
     include Emitter
     include Error
 
+    STREAM_OPEN_STATES = %i[open half_closed_local half_closing closing].freeze
+
     # Stream ID (odd for client initiated streams, even otherwise).
     attr_reader :id
 
@@ -80,6 +82,11 @@ module HTTP2
       @id = id
       @weight = weight
       @dependency = dependency
+
+      # from mixins
+      @listeners = Hash.new { |hash, key| hash[key] = [] }
+      @send_buffer = FrameBuffer.new
+
       process_priority(weight: weight, dependency: dependency, exclusive: exclusive)
       @local_window_max_size = connection.local_settings[:settings_initial_window_size]
       @local_window = connection.local_settings[:settings_initial_window_size]
@@ -88,7 +95,7 @@ module HTTP2
       @state  = state
       @error  = false
       @closed = false
-      @_method = @_content_length = @_status_code = nil
+      @_method = @_content_length = @_status_code = @_trailers = nil
       @_waiting_on_trailers = false
       @received_data = false
       @activated = false
@@ -113,9 +120,7 @@ module HTTP2
         # If a DATA frame is received whose stream is not in "open" or
         # "half closed (local)" state, the recipient MUST respond with a
         # stream error (Section 5.4.2) of type STREAM_CLOSED.
-        stream_error(:stream_closed) unless @state == :open ||
-                                            @state == :half_closed_local ||
-                                            @state == :half_closing || @state == :closing ||
+        stream_error(:stream_closed) unless STREAM_OPEN_STATES.include?(@state) ||
                                             (@state == :closed && @closed == :local_rst)
         @received_data = true
         calculate_content_length(frame[:length])
@@ -192,21 +197,18 @@ module HTTP2
     #
     # @param frame [Hash]
     def send(frame)
-      process_priority(frame) if frame[:type] == :priority
-
       case frame[:type]
       when :data
-        # @remote_window is maintained in send_data
-        send_data(frame)
+        # stream state management is maintained in send_data
+        return send_data(frame)
       when :window_update
-        manage_state(frame) do
-          @local_window += frame[:increment]
-          emit(:frame, frame)
-        end
-      else
-        manage_state(frame) do
-          emit(:frame, frame)
-        end
+        @local_window += frame[:increment]
+      when :priority
+        process_priority(frame)
+      end
+
+      manage_state(frame) do
+        emit(:frame, frame)
       end
     end
 
@@ -379,7 +381,7 @@ module HTTP2
             else
               event(:open)
             end
-          when :priority then process_priority(frame)
+          when :priority
           else stream_error(:protocol_error)
           end
         end
@@ -400,19 +402,20 @@ module HTTP2
       # WINDOW_UPDATE on a stream in this state MUST be treated as a
       # connection error (Section 5.4.1) of type PROTOCOL_ERROR.
       when :reserved_local
-        @state = if sending
-                   case frame[:type]
-                   when :headers     then event(:half_closed_remote)
-                   when :rst_stream  then event(:local_rst)
-                   else stream_error
-                   end
-                 else
-                   case frame[:type]
-                   when :rst_stream then event(:remote_rst)
-                   when :priority, :window_update then @state
-                   else stream_error
-                   end
-                 end
+        if sending
+          case frame[:type]
+          when :headers     then event(:half_closed_remote)
+          when :rst_stream  then event(:local_rst)
+          when :priority
+          else stream_error
+          end
+        else
+          case frame[:type]
+          when :rst_stream then event(:remote_rst)
+          when :priority, :window_update
+          else stream_error
+          end
+        end
 
       # A stream in the "reserved (remote)" state has been reserved by a
       # remote peer.
@@ -429,19 +432,20 @@ module HTTP2
       # PRIORITY on a stream in this state MUST be treated as a connection
       # error (Section 5.4.1) of type PROTOCOL_ERROR.
       when :reserved_remote
-        @state = if sending
-                   case frame[:type]
-                   when :rst_stream then event(:local_rst)
-                   when :priority, :window_update then @state
-                   else stream_error
-                   end
-                 else
-                   case frame[:type]
-                   when :headers then event(:half_closed_local)
-                   when :rst_stream then event(:remote_rst)
-                   else stream_error
-                   end
-                 end
+        if sending
+          case frame[:type]
+          when :rst_stream then event(:local_rst)
+          when :priority, :window_update
+          else stream_error
+          end
+        else
+          case frame[:type]
+          when :headers then event(:half_closed_local)
+          when :rst_stream then event(:remote_rst)
+          when :priority
+          else stream_error
+          end
+        end
 
       # A stream in the "open" state may be used by both peers to send
       # frames of any type.  In this state, sending peers observe
@@ -460,12 +464,14 @@ module HTTP2
           when :data, :headers, :continuation
             event(:half_closed_local) if end_stream?(frame)
           when :rst_stream then event(:local_rst)
+          when :priority
           end
         else
           case frame[:type]
           when :data, :headers, :continuation
             event(:half_closed_remote) if end_stream?(frame)
           when :rst_stream then event(:remote_rst)
+          when :priority
           end
         end
 
@@ -485,10 +491,7 @@ module HTTP2
           case frame[:type]
           when :rst_stream
             event(:local_rst)
-          when :priority
-            process_priority(frame)
-          when :window_update
-            # nop here
+          when :priority, :window_update
           else
             stream_error
           end
@@ -497,10 +500,7 @@ module HTTP2
           when :data, :headers, :continuation
             event(:remote_closed) if end_stream?(frame)
           when :rst_stream then event(:remote_rst)
-          when :priority
-            process_priority(frame)
-          when :window_update
-            # nop here
+          when :priority, :window_update
           end
         end
 
@@ -529,9 +529,7 @@ module HTTP2
         else
           case frame[:type]
           when :rst_stream then event(:remote_rst)
-          when :priority
-            process_priority(frame)
-          when :window_update
+          when :priority, :window_update
             # nop
           else
             stream_error(:stream_closed)
@@ -579,19 +577,15 @@ module HTTP2
       when :closed
         if sending
           case frame[:type]
-          when :rst_stream # ignore
-          when :priority
-            process_priority(frame)
+          when :rst_stream, :priority
           else
             stream_error(:stream_closed) unless frame[:type] == :rst_stream
           end
-        elsif frame[:type] == :priority
-          process_priority(frame)
         else
           case @closed
           when :remote_rst, :remote_closed
             case frame[:type]
-            when :rst_stream, :window_update # nop here
+            when :priority, :rst_stream, :window_update # nop here
             else
               stream_error(:stream_closed)
             end

data/lib/http/2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP2
-  VERSION = "1.0.2"
+  VERSION = "1.1.1"
 end

data/lib/http/2.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 require "http/2/version"
+
+module HTTP2
+  EMPTY = [].freeze
+end
+
 require "http/2/extensions"
 require "http/2/base64"
 require "http/2/error"

data/sig/{next.rbs → 2.rbs}

@@ -7,7 +7,18 @@ module HTTP2
 
   DEFAULT_MAX_CONCURRENT_STREAMS: Integer
 
-  type settings_hash = Hash[Symbol, Integer]
+  EMPTY: []
+
+  type connection_opts = Hash[Symbol, untyped]
+
+  type settings_hash = {
+    settings_header_table_size: Integer,
+    settings_enable_push: Integer,
+    settings_max_concurrent_streams:  Integer,
+    settings_initial_window_size: Integer,
+    settings_max_frame_size: Integer,
+    settings_max_header_list_size: Integer
+  }
 
   type settings_ary = Array[settings_enum]
 
@@ -30,44 +41,44 @@ module HTTP2
   # # FRAMES
   type frame_control_flags = Array[:end_headers | :end_stream]
 
+  type common_frame = { stream: Integer }
+
   # # HEADERS
-  # type headers_frame = {
-  #   type: :headers, flags: frame_control_flags, stream: Integer, payload: Enumerable[header_pair],
-  #   ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, ?padding: Integer
-  # }
+  type headers_frame = common_frame & {
+    type: :headers, flags: frame_control_flags, payload: Enumerable[header_pair] | String,
+    ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, ?padding: Integer
+  }
 
   # # DATA
-  type data_frame = { type: :data, flags: frame_control_flags, stream: Integer, length: Integer, payload: String, padding: Integer }
-                  | { type: :data, flags: frame_control_flags, stream: Integer, length: Integer, payload: String }
-                  | { type: :data, flags: frame_control_flags, payload: String }
+  type data_frame = { type: :data, flags: frame_control_flags, ?length: Integer, payload: String, ?padding: Integer }
 
   # # PUSH_PROMISE
-  # type push_promise_frame = { type: :push_promise, promise_stream: Integer, flags: frame_control_flags, stream: Integer, ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, payload: Enumerable[header_pair], ?padding: Integer }
+  type push_promise_frame = { type: :push_promise, promise_stream: Integer, flags: frame_control_flags, ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, payload: Enumerable[header_pair], ?padding: Integer }
 
   # # SETTINGS
-  # type settings_frame = { type: :settings, stream: 0, payload: Array[[Symbol | Integer, Integer]] }
+  type settings_frame = { type: :settings, payload: Array[[Symbol | Integer, Integer]] }
 
   # # WINDOW_UPDATE
-  # type window_update_frame = { type: :window_update, stream: Integer, increment: Integer }
+  type window_update_frame = { type: :window_update, increment: Integer }
 
   # # PRIORITY
-  type priority_frame = { type: :priority, stream: Integer, dependency: Integer, exclusive: bool, weight: Integer }
+  type priority_frame = { dependency: Integer, exclusive: bool, weight: Integer }
 
   # # ALTSVC
-  # type altsvc_frame = { type: :altsvc, stream: 0, max_age: Integer, port: Integer, proto: "String", host: String }
+  type altsvc_frame = { type: :altsvc, max_age: Integer, port: Integer, proto: "String", host: String }
 
   # # ORIGIN
-  # type origin_frame = { type: :origin, stream: 0, origin: Array[String] }
+  type origin_frame = { type: :origin, origin: Array[String] }
 
   # # PING
-  # type ping_frame = { type: :ping, payload: String, length: Integer }
+  type ping_frame = { type: :ping, payload: String, length: Integer }
 
   # # GOAWAY
-  # type goaway_frame = { type: :goaway, stream: 0, last_stream: Integer, error: Symbol? }
+  type goaway_frame = { type: :goaway, last_stream: Integer, error: Symbol? }
 
-  # type frame = headers_frame | data_frame | push_promise_frame |
+  # type frame = common_frame & (headers_frame | data_frame | push_promise_frame |
   #              settings_frame | window_update_frame | priority_frame | altsvc_frame |
-  #              origin_frame | ping_frame | goaway_frame
+  #              origin_frame | ping_frame | goaway_frame)
 
   type frame_key = :type | :flags | :stream | :padding | :ignore |
                    # headers

data/sig/client.rbs

@@ -1,5 +1,7 @@
 module HTTP2
   class Client < Connection
+    @h2c_upgrade: Symbol?
+
     def upgrade: () -> Stream
 
     def send_connection_preface: () -> void

data/sig/connection.rbs

@@ -5,8 +5,15 @@ module HTTP2
     include BufferUtils
 
     REQUEST_MANDATORY_HEADERS: Array[String]
+
     RESPONSE_MANDATORY_HEADERS: Array[String]
 
+    CONNECTION_FRAME_TYPES: Array[Symbol]
+
+    HEADERS_FRAME_TYPES: Array[Symbol]
+
+    STREAM_OPEN_STATES: Array[Symbol]
+
     attr_reader state: Symbol
 
     attr_reader local_window: Integer
@@ -22,14 +29,18 @@ module HTTP2
 
     @stream_id: Integer
     @active_stream_count: Integer
-    @last_activated_stream: Integer
     @last_stream_id: Integer
 
     @streams: Hash[Integer, Stream]
-    @streams_recently_closed: Hash[Integer, Stream]
+    @streams_recently_closed: Hash[Integer, Numeric]
 
     @framer: Framer
 
+    type role_type = :client | :server
+
+    @local_role: role_type
+    @remote_role: role_type
+
     @local_window_limit: Integer
     @remote_window_limit: Integer
 
@@ -40,6 +51,7 @@ module HTTP2
     @recv_buffer: String
     @continuation: Array[frame]
 
+    @h2c_upgrade: Symbol?
     @closed_since: Float?
     @received_frame: bool
 
@@ -54,18 +66,18 @@ module HTTP2
 
     def window_update: (Integer increment) -> void
 
-    def settings: (settings_enum) -> void
+    def settings: (settings_enum payload) -> void
 
     def receive: (string data) -> void
     alias << receive
 
-    def initialize: (?settings_hash) -> void
+    def initialize: (?connection_opts) -> void
 
     private
 
-    def send: (frame) -> void
+    def send: (frame frame) -> void
 
-    def encode: (frame) -> Array[String]
+    def encode: (frame frame) -> void
 
     def connection_frame?: (frame) -> bool
 
@@ -73,13 +85,13 @@ module HTTP2
 
     def ping_management: (frame) -> void
 
-    def validate_settings: (:client | :server, settings_enum) -> void
+    def validate_settings: (role_type, settings_enum) -> void
 
     def connection_settings: (frame) -> void
 
     def decode_headers: (frame) -> void
 
-    def encode_headers: (frame) -> Array[frame]
+    def encode_headers: (frame headers_frame) -> void
 
     def activate_stream: (id: Integer, **untyped) -> Stream
 

data/sig/emitter.rbs

@@ -1,13 +1,11 @@
 module HTTP2
   module Emitter
+    @listeners: Hash[Symbol, Array[^(*untyped) -> void]]
+
     def on: (Symbol event) { (*untyped) -> void } -> void
 
     def once: (Symbol event) { (*untyped) -> void } -> void
 
     def emit: (Symbol event, *untyped args) ?{ (*untyped) -> void } -> void
-
-    private
-
-    def listeners: (Symbol event)  -> Array[Proc]
   end
 end

data/sig/extensions.rbs

@@ -1,5 +1,7 @@
 module HTTP2
   module BufferUtils
+    def append_str: (String str, String data) -> void
+
     def read_str: (String str, Integer n) -> String
 
     def read_uint32: (String str) -> Integer
@@ -8,6 +10,6 @@ module HTTP2
   end
 
   module PackingExtensions
-    def pack: (Array[Integer] array_to_pack, String template, buffer: String, ?offset: Integer) -> String
+    def pack: (Array[Integer | String] array_to_pack, String template, buffer: String, ?offset: Integer) -> String
   end
 end

data/sig/flow_buffer.rbs

@@ -2,20 +2,22 @@ module HTTP2
   module FlowBuffer
     MAX_WINDOW_SIZE: Integer
 
+    attr_reader send_buffer: FrameBuffer
+
     def buffered_amount: () -> Integer
 
     def flush: () -> void
 
     private
 
-    def send_buffer: () -> FrameBuffer
-
-    def update_local_window: (frame) -> void
+    def update_local_window: (data_frame frame) -> void
 
     def calculate_window_update: (Integer) -> void
 
-    def send_data: (?frame? frame, ?bool encode) -> void
+    def send_data: (?data_frame? frame, ?bool encode) -> void
+
+    def send_frame: (data_frame frame, bool encode) -> void
 
-    def process_window_update: (frame: frame, ?encode: bool) -> void
+    def process_window_update: (frame: window_update_frame, ?encode: bool) -> void
   end
 end

data/sig/frame_buffer.rbs

@@ -4,7 +4,7 @@ module HTTP2
 
     @buffer: Array[data_frame]
 
-    def <<: (data_frame) -> void
+    def <<: (data_frame frame) -> void
 
     def empty?: () -> bool
 

data/sig/framer.rbs

@@ -1,5 +1,6 @@
 module HTTP2
   class Framer
+    include Error
     include PackingExtensions
     include BufferUtils
 
@@ -11,6 +12,8 @@ module HTTP2
 
     FRAME_TYPES: Hash[Symbol, Integer]
 
+    FRAME_TYPES_BY_NAME: Array[Symbol]
+
     FRAME_TYPES_WITH_PADDING: Array[Symbol]
 
     FRAME_FLAGS: Hash[Symbol, Hash[Symbol, Integer]]
@@ -38,6 +41,8 @@ module HTTP2
 
     def common_header: (frame, buffer: String) -> String
 
+    def read_common_header: (String buf) -> frame
+
     def read_common_frame: (String) -> frame
 
     def generate: (frame) -> String

data/sig/header/compressor.rbs

@@ -9,7 +9,7 @@ module HTTP2
 
       def integer: (Integer, Integer, buffer: String, ?offset: Integer) -> String
 
-      def string: (String) -> String
+      def string: (String, ?String buffer) -> String
 
       def header: (header_command, ?String) -> String
 
@@ -17,11 +17,13 @@ module HTTP2
 
       private
 
-      def initialize: (?context_hash options) -> void
+      def initialize: (?connection_opts options) -> void
 
-      def huffman_string: (String str) -> String
+      def huffman_string: (String str, ?String buffer) -> String
 
-      def plain_string: (String str) -> String
+      def plain_string: (String str, ?String buffer) -> String
+
+      def set_huffman_size: (String str, Integer huffman_offset) -> String
     end
   end
 end

data/sig/header/decompressor.rbs

@@ -3,6 +3,8 @@ module HTTP2
     class Decompressor
       include BufferUtils
 
+      FORBIDDEN_HEADERS: Array[String]
+
       @cc: EncodingContext
 
       def table_size=: (Integer) -> void
@@ -17,8 +19,7 @@ module HTTP2
                 | (String) -> Array[header_pair]
       private
 
-      def initialize: (context_hash options) -> untyped
-                    | () -> untyped
+      def initialize: (?connection_opts options) -> void
     end
   end
 end

data/sig/header/encoding_context.rbs

@@ -3,32 +3,50 @@ module HTTP2
     class EncodingContext
       STATIC_TABLE: Array[header_pair]
 
+      STATIC_TABLE_BY_FIELD: Hash[String, Array[[Integer, String]]]
+
+      STATIC_TABLE_SIZE: Integer
+
+      STATIC_ALL: Array[Symbol]
+
+      STATIC_NEVER: Array[Symbol]
+
+      DEFAULT_OPTIONS: context_hash
+
+      UPPER: Regexp
+
+
       attr_reader table: Array[header_pair]
 
       attr_reader options: context_hash
 
+      attr_reader current_table_size: Integer
+
+      @limit: Integer
+
+      @_table_updated: bool
+
       def dup: () -> EncodingContext
 
       def dereference: (Integer) -> header_pair
 
       def process: (header_command cmd) -> header_pair?
 
-      def encode: (_Each[header_pair]) -> Array[header_command]
+      def encode: (_Each[header_pair]) { (header_command) -> void } -> void
 
       def addcmd: (String name, String value) -> header_command
 
       def table_size=: (Integer) -> void
 
-      def current_table_size: () -> Integer
+      def listen_on_table: { () -> void } -> void
 
       private
 
-      def initialize: (context_hash options) -> untyped
-                    | () -> untyped
+      def initialize: (?connection_opts options) -> void
 
-      def add_to_table: (header_pair) -> void
+      def add_to_table: (string name, string value) -> void
 
-      def size_check: (header_pair?) -> bool
+      def size_check: (Integer cmdsize) -> bool
     end
   end
 end

data/sig/header/huffman.rbs

@@ -1,9 +1,25 @@
 module HTTP2
   module Header
-    class Huffman
-      def encode: (String str) -> String
+    module Huffman
+      include Error
+      extend PackingExtensions
+      extend BufferUtils
 
-      def decode: (String str) -> String
+      BITS_AT_ONCE: Integer
+
+      EOS: Integer
+
+      CODES: Array[[Integer, Integer]]
+
+      ENCODE_TABLE: Array[String]
+
+      MAX_FINAL_STATE: Integer
+
+      MACHINE: Array[Array[[Integer?, Integer]]]
+
+      def self?.encode: (String str, ?String buffer) -> String
+
+      def self?.decode: (String str) -> String
     end
   end
 end

data/sig/header.rbs

@@ -3,16 +3,19 @@ module HTTP2
     type header_key = :type | :name | :value | :index
     type header_value = Integer | String | :indexed | :changetablesize | :incremental | :noindex | :neverindexed
 
-    #type context_hash = {
-    #  huffman?: (:always | :never | :shorter),
-    #  index?: (:all | :static | :never),
-    #  table_size?: Integer
-    #}
-    type context_hash = Hash[Symbol, Symbol | Integer]
+    type context_hash = {
+     huffman: (:always | :never | :shorter),
+     index: (:all | :static | :never),
+     table_size: Integer
+    }
 
-    type header_command = Hash[header_key, header_value]
+    type header_type = :indexed | :incremental | :noindex | :neverindexed | :changetablesize
 
-    HEADREP: Hash[Symbol, Hash[Symbol, Integer]]
+    type header_command = { type: :indexed , name: Integer } |
+                          { type: (:incremental | :noindex | :neverindexed), name: Integer | String, value: String } |
+                          { type: :changetablesize, ?name: Integer, value: Integer }
+
+    HEADREP: Hash[header_type, { prefix: Integer, pattern: Integer }]
 
     NAIVE: Hash[Symbol, Symbol]
     LINEAR: Hash[Symbol, Symbol]