http-2 0.8.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df6b5bd32b2217bebfb3205cfab1bd78f2a5456d
-  data.tar.gz: eb9d683a528819195bf81d4480549b2d8ac7bab6
+  metadata.gz: f37bf7f07706136db469b5c188cf13b2995d0c16
+  data.tar.gz: e51aeb9218b11e3cada90485ba60b5342e89322f
 SHA512:
-  metadata.gz: 686e87ef8beeedd1f3ac1371845b759687231ba62e3bab532d3d15d65febc179bc19f44d4a025708ecc62e2f0e7dd0689cfbbeef19e47c8ee52df9d050066228
-  data.tar.gz: 41b003cfeb4a127efcf9d4709167db3ff40934a175a08bd19d23a3874d6dd7e615f99ab967c5b85b521e54a4cdbfce33b4087c6ddde7eebd0d0fc11d18a4d551
+  metadata.gz: 45ca021e60dfe824fcc7bc6bf61d054ce37096a7f0f41ba7c1a5e45f89ad7848f37f4d6638f28d6a93bf6b41f28e8af66abfac28b4fe60d16556d82c1ec78ae3
+  data.tar.gz: c5bddd633904cd5ff9aef237debbdbcc78a6b901dad857cd5aa770e8d13ea28e26c158c902f9b840185b4a8d7dfe7c8e2acd9b380991426f0b5abdbfa4bc2f2f

data/.rubocop_todo.yml

@@ -37,7 +37,7 @@ Metrics/MethodLength:
 # Offense count: 1
 # Configuration parameters: CountKeywordArgs.
 Metrics/ParameterLists:
-  Max: 6
+  Max: 7
 
 # Offense count: 10
 Metrics/PerceivedComplexity:

data/example/client.rb

@@ -55,6 +55,10 @@ conn.on(:frame_received) do |frame|
 end
 
 conn.on(:promise) do |promise|
+  promise.on(:promise_headers) do |h|
+    log.info "promise request headers: #{h}"
+  end
+
   promise.on(:headers) do |h|
     log.info "promise headers: #{h}"
   end

data/example/server.rb

@@ -36,9 +36,7 @@ if options[:secure]
     DRAFT
   end
 
-  ctx.tmp_ecdh_callback = lambda do |*_args|
-    OpenSSL::PKey::EC.new 'prime256v1'
-  end
+  ctx.ecdh_curves = 'P-256'
 
   server = OpenSSL::SSL::SSLServer.new(server, ctx)
 end

data/example/upgrade_client.rb

@@ -0,0 +1,154 @@
+# frozen_string_literals: true
+
+require_relative 'helper'
+require 'http_parser'
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: upgrade_client.rb [options]'
+end.parse!
+
+uri = URI.parse(ARGV[0] || 'http://localhost:8080/')
+sock = TCPSocket.new(uri.host, uri.port)
+
+conn = HTTP2::Client.new
+
+def request_header_hash
+  Hash.new do |hash, key|
+    k = key.to_s.downcase
+    k.tr! '_', '-'
+    _, value = hash.find { |header_key, _| header_key.downcase == k }
+    hash[key] = value if value
+  end
+end
+
+conn.on(:frame) do |bytes|
+  sock.print bytes
+  sock.flush
+end
+conn.on(:frame_sent) do |frame|
+  puts "Sent frame: #{frame.inspect}"
+end
+conn.on(:frame_received) do |frame|
+  puts "Received frame: #{frame.inspect}"
+end
+
+# upgrader module
+class UpgradeHandler
+  UPGRADE_REQUEST = <<-RESP.freeze
+GET %s HTTP/1.1
+Connection: Upgrade, HTTP2-Settings
+HTTP2-Settings: #{HTTP2::Client.settings_header(settings_max_concurrent_streams: 100)}
+Upgrade: h2c
+Host: %s
+User-Agent: http-2 upgrade
+Accept: */*
+
+RESP
+
+  attr_reader :complete, :parsing
+  def initialize(conn, sock)
+    @conn = conn
+    @sock = sock
+    @headers = request_header_hash
+    @body = ''.b
+    @complete, @parsing = false, false
+    @parser = ::HTTP::Parser.new(self)
+  end
+
+  def request(uri)
+    host = "#{uri.hostname}#{":#{uri.port}" if uri.port != uri.default_port}"
+    req = format(UPGRADE_REQUEST, uri.request_uri, host)
+    puts req
+    @sock << req
+  end
+
+  def <<(data)
+    @parsing ||= true
+    @parser << data
+    return unless complete
+    upgrade
+  end
+
+  def complete!
+    @complete = true
+  end
+
+  def on_headers_complete(h)
+    @headers.merge!(h)
+    puts "received headers: #{h}"
+  end
+
+  def on_body(chunk)
+    puts "received chunk: #{chunk}"
+    @body << chunk
+  end
+
+  def on_message_complete
+    fail 'could not upgrade to h2c' unless @parser.status_code == 101
+    @parsing = false
+    complete!
+  end
+
+  def upgrade
+    stream = @conn.upgrade
+    log = Logger.new(stream.id)
+
+    stream.on(:close) do
+      log.info 'stream closed'
+    end
+
+    stream.on(:half_close) do
+      log.info 'closing client-end of the stream'
+    end
+
+    stream.on(:headers) do |h|
+      log.info "response headers: #{h}"
+    end
+
+    stream.on(:data) do |d|
+      log.info "response data chunk: <<#{d}>>"
+    end
+
+    stream.on(:altsvc) do |f|
+      log.info "received ALTSVC #{f}"
+    end
+
+    @conn.on(:promise) do |promise|
+      promise.on(:headers) do |h|
+        log.info "promise headers: #{h}"
+      end
+
+      promise.on(:data) do |d|
+        log.info "promise data chunk: <<#{d.size}>>"
+      end
+    end
+
+    @conn.on(:altsvc) do |f|
+      log.info "received ALTSVC #{f}"
+    end
+  end
+end
+
+uh = UpgradeHandler.new(conn, sock)
+puts 'Sending HTTP/1.1 upgrade request'
+uh.request(uri)
+
+while !sock.closed? && !sock.eof?
+  data = sock.read_nonblock(1024)
+
+  begin
+    if !uh.parsing && !uh.complete
+      uh << data
+    elsif uh.parsing && !uh.complete
+      uh << data
+    elsif uh.complete
+      conn << data
+    end
+
+  rescue => e
+    puts "#{e.class} exception: #{e.message} - closing socket."
+    e.backtrace.each { |l| puts "\t" + l }
+    conn.close
+    sock.close
+  end
+end

data/lib/http/2/client.rb

@@ -38,6 +38,13 @@ module HTTP2
       super(frame)
     end
 
+    # sends the preface and initializes the first stream in half-closed state
+    def upgrade
+      fail ProtocolError unless @stream_id == 1
+      send_connection_preface
+      new_stream(state: :half_closed_local)
+    end
+
     # Emit the connection preface if not yet
     def send_connection_preface
       return unless @state == :waiting_connection_preface
@@ -47,5 +54,10 @@ module HTTP2
       payload = @local_settings.select { |k, v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
       settings(payload)
     end
+
+    def self.settings_header(**settings)
+      frame = Framer.new.generate(type: :settings, stream: 0, payload: settings)
+      Base64.urlsafe_encode64(frame[9..-1])
+    end
   end
 end

data/lib/http/2/compressor.rb

@@ -199,8 +199,12 @@ module HTTP2
         commands = []
         # Literals commands are marked with :noindex when index is not used
         noindex = [:static, :never].include?(@options[:index])
-        headers.each do |h|
-          cmd = addcmd(h)
+        headers.each do |field, value|
+          # Literal header names MUST be translated to lowercase before
+          # encoding and transmission.
+          field = field.downcase
+          value = '/' if field == ':path' && value.empty?
+          cmd = addcmd(field, value)
           cmd[:type] = :noindex if noindex && cmd[:type] == :incremental
           commands << cmd
           process(cmd)
@@ -220,7 +224,7 @@ module HTTP2
       #
       # @param header [Array] +[name, value]+
       # @return [Hash] command
-      def addcmd(header)
+      def addcmd(*header)
         exact = nil
         name_only = nil
 
@@ -442,10 +446,6 @@ module HTTP2
       def encode(headers)
         buffer = Buffer.new
 
-        # Literal header names MUST be translated to lowercase before
-        # encoding and transmission.
-        headers.map! { |hk, hv| [hk.downcase, hv] }
-
         commands = @cc.encode(headers)
         commands.each do |cmd|
           buffer << header(cmd)

data/lib/http/2/connection.rb

@@ -147,6 +147,7 @@ module HTTP2
     #
     # @param increment [Integer]
     def window_update(increment)
+      @local_window += increment
       send(type: :window_update, stream: 0, increment: increment)
     end
 
@@ -312,6 +313,10 @@ module HTTP2
           else
             if (stream = @streams[frame[:stream]])
               stream << frame
+              if frame[:type] == :data
+                update_local_window(frame)
+                calculate_window_update(@local_window_limit)
+              end
             else
               case frame[:type]
               # The PRIORITY frame can be sent for a stream in the "idle" or
@@ -664,7 +669,6 @@ module HTTP2
 
       stream.on(:promise, &method(:promise)) if self.is_a? Server
       stream.on(:frame,   &method(:send))
-      stream.on(:window_update, &method(:window_update))
 
       @streams[id] = stream
     end
@@ -689,6 +693,7 @@ module HTTP2
       backtrace = (e && e.backtrace) || []
       fail Error.const_get(klass), msg, backtrace
     end
+    alias error connection_error
 
     def manage_state(_)
       yield

data/lib/http/2/flow_buffer.rb

@@ -13,6 +13,37 @@ module HTTP2
 
     private
 
+    def update_local_window(frame)
+      frame_size = frame[:payload].bytesize
+      frame_size += frame[:padding] || 0
+      @local_window -= frame_size
+    end
+
+    def calculate_window_update(window_max_size)
+      # If DATA frame is received with length > 0 and
+      # current received window size + delta length is strictly larger than
+      # local window size, it throws a flow control error.
+      #
+      error(:flow_control_error) if @local_window < 0
+
+      # Send WINDOW_UPDATE if the received window size goes over
+      # the local window size / 2.
+      #
+      # The HTTP/2 spec mandates that every DATA frame received
+      # generates a WINDOW_UPDATE to send. In some cases however,
+      # (ex: DATA frames with short payloads),
+      # the noise generated by flow control frames creates enough
+      # congestion for this to be deemed very inefficient.
+      #
+      # This heuristic was inherited from nghttp, which delays the
+      # WINDOW_UPDATE until at least half the window is exhausted.
+      # This works because the sender doesn't need those increments
+      # 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
+
     # Buffers outgoing DATA frames and applies flow control logic to split
     # and emit DATA frames based on current flow control window. If the
     # window is large enough, the data is sent immediately. Otherwise, the

data/lib/http/2/stream.rb

@@ -71,22 +71,24 @@ module HTTP2
     # @param exclusive [Boolean]
     # @param window [Integer]
     # @param parent [Stream]
-    def initialize(connection:, id:, weight: 16, dependency: 0, exclusive: false, parent: nil)
+    # @param state [Symbol]
+    def initialize(connection:, id:, weight: 16, dependency: 0, exclusive: false, parent: nil, state: :idle)
       @connection = connection
       @id = id
       @weight = weight
       @dependency = dependency
       process_priority(weight: weight, stream_dependency: dependency, exclusive: exclusive)
+      @local_window_max_size = connection.local_settings[:settings_initial_window_size]
       @local_window  = connection.local_settings[:settings_initial_window_size]
       @remote_window = connection.remote_settings[:settings_initial_window_size]
       @parent = parent
-      @state  = :idle
+      @state  = state
       @error  = false
       @closed = false
       @send_buffer = []
 
       on(:window) { |v| @remote_window = v }
-      on(:local_window) { |v| @local_window = v }
+      on(:local_window) { |v| @local_window_max_size = @local_window = v }
     end
 
     # Processes incoming HTTP 2.0 frames. The frames must be decoded upstream.
@@ -97,16 +99,14 @@ module HTTP2
 
       case frame[:type]
       when :data
-        window_size = frame[:payload].bytesize
-        window_size += frame[:padding] || 0
-        @local_window -= window_size
+        update_local_window(frame)
+        # Emit DATA frame
         emit(:data, frame[:payload]) unless frame[:ignore]
-
-        # Automatically send WINDOW_UPDATE,
-        # assuming that emit(:data) can now receive next data
-        window_update(window_size) if window_size > 0
-      when :headers, :push_promise
+        calculate_window_update(@local_window_max_size)
+      when :headers
         emit(:headers, frame[:payload]) unless frame[:ignore]
+      when :push_promise
+        emit(:promise_headers, frame[:payload]) unless frame[:ignore]
       when :priority
         process_priority(frame)
       when :window_update
@@ -153,7 +153,7 @@ module HTTP2
       flags << :end_headers if end_headers
       flags << :end_stream  if end_stream
 
-      send(type: :headers, flags: flags, payload: headers.to_a)
+      send(type: :headers, flags: flags, payload: headers)
     end
 
     def promise(headers, end_headers: true, &block)
@@ -228,8 +228,6 @@ module HTTP2
     #
     # @param increment [Integer]
     def window_update(increment)
-      # always emit connection-level WINDOW_UPDATE
-      emit(:window_update, increment)
       # emit stream-level WINDOW_UPDATE unless stream is closed
       return if @state == :closed || @state == :remote_closed
       send(type: :window_update, increment: increment)
@@ -602,6 +600,7 @@ module HTTP2
       klass = error.to_s.split('_').map(&:capitalize).join
       fail Error.const_get(klass), msg
     end
+    alias error stream_error
 
     def manage_state(frame)
       transition(frame, true)

data/lib/http/2/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = '0.8.4'.freeze
+  VERSION = '0.9.0'.freeze
 end

data/spec/client_spec.rb

@@ -34,6 +34,23 @@ RSpec.describe HTTP2::Client do
     end
   end
 
+  context 'upgrade' do
+    it 'fails when client has already created streams' do
+      @client.new_stream
+      expect { @client.upgrade }.to raise_error(HTTP2::Error::ProtocolError)
+    end
+
+    it 'sends the preface' do
+      expect(@client).to receive(:send_connection_preface)
+      @client.upgrade
+    end
+
+    it 'initializes the first stream in the half-closed state' do
+      stream = @client.upgrade
+      expect(stream.state).to be(:half_closed_local)
+    end
+  end
+
   context 'push' do
     it 'should disallow client initiated push' do
       expect do
@@ -69,12 +86,28 @@ RSpec.describe HTTP2::Client do
 
       promise = nil
       @client.on(:promise) { |stream| promise = stream }
-      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+      @client << set_stream_id(f.generate(PUSH_PROMISE.deep_dup), s.id)
 
       expect(promise.id).to eq 2
       expect(promise.state).to eq :reserved_remote
     end
 
+    it 'should emit promise headers for received PUSH_PROMISE' do
+      header = nil
+      s = @client.new_stream
+      s.send HEADERS.deep_dup
+
+      @client.on(:promise) do |stream|
+        stream.on(:promise_headers) do |h|
+          header = h
+        end
+      end
+      @client << set_stream_id(f.generate(PUSH_PROMISE.deep_dup), s.id)
+
+      expect(header).to be_a(Array)
+      # expect(header).to eq([%w(a b)])
+    end
+
     it 'should auto RST_STREAM promises against locally-RST stream' do
       s = @client.new_stream
       s.send HEADERS.deep_dup

data/spec/compressor_spec.rb

@@ -237,6 +237,18 @@ RSpec.describe HTTP2::Header do
         expect(cc.table.first[0]).to eq 'test2'
       end
     end
+
+    context 'encode' do
+      it 'downcases the field' do
+        expect(EncodingContext.new.encode([['Content-Length', '5']]))
+          .to eq(EncodingContext.new.encode([['content-length', '5']]))
+      end
+
+      it 'fills :path if empty' do
+        expect(EncodingContext.new.encode([[':path', '']]))
+          .to eq(EncodingContext.new.encode([[':path', '/']]))
+      end
+    end
   end
 
   spec_examples = [

data/spec/connection_spec.rb

@@ -237,6 +237,28 @@ RSpec.describe HTTP2::Connection do
       expect(@conn.buffered_amount).to eq 0
       expect(@conn.remote_window).to eq 900
     end
+
+    it 'should update window when data received is over half of the maximum local window size' do
+      settings, data = SETTINGS.dup, DATA.dup
+      conn = Client.new(settings_initial_window_size: 500)
+
+      conn.receive f.generate(settings)
+      s1 = conn.new_stream
+      s2 = conn.new_stream
+
+      s1.send HEADERS.deep_dup
+      s2.send HEADERS.deep_dup
+      expect(conn).to receive(:send) do |frame|
+        expect(frame[:type]).to eq :window_update
+        expect(frame[:stream]).to eq 0
+        expect(frame[:increment]).to eq 400
+      end
+      conn.receive f.generate(data.merge(payload: 'x' * 200, end_stream: false, stream: s1.id))
+      conn.receive f.generate(data.merge(payload: 'x' * 200, end_stream: false, stream: s2.id))
+      expect(s1.local_window).to eq 300
+      expect(s2.local_window).to eq 300
+      expect(conn.local_window).to eq 500
+    end
   end
 
   context 'framing' do

data/spec/stream_spec.rb

@@ -598,19 +598,28 @@ RSpec.describe HTTP2::Stream do
       expect(s1.remote_window).to eq 900
     end
 
-    it 'should keep track of incoming flow control' do
+    it 'should not update window when data received is less than half of maximum local window size' do
       data = DATA.deep_dup
       datalen = data[:payload].bytesize
-      expect(@stream).to receive(:send) do |frame|
+      expect(@stream).not_to receive(:send) do |frame|
         expect(frame[:type]).to eq :window_update
         expect(frame[:increment]).to eq datalen
       end
-      expect(@client).to receive(:send) do |frame|
+      @stream.receive HEADERS.deep_dup
+      @stream.receive data
+    end
+
+    it 'should update window when data received is over half of the maximum local window size' do
+      data1 = DATA.merge(payload: 'a'*16_384, flags: [])
+      data2 = DATA.merge(payload: 'a'*16_384)
+      datalen = 16_384 * 2
+      expect(@stream).to receive(:send) do |frame|
         expect(frame[:type]).to eq :window_update
         expect(frame[:increment]).to eq datalen
       end
       @stream.receive HEADERS.deep_dup
-      @stream.receive data
+      @stream.receive data1
+      @stream.receive data2
     end
   end
 
@@ -642,7 +651,7 @@ RSpec.describe HTTP2::Stream do
 
       expect(@stream).to receive(:send) do |frame|
         expect(frame[:type]).to eq :headers
-        expect(frame[:payload]).to eq payload.to_a
+        expect(frame[:payload]).to eq payload
         expect(frame[:flags]).to eq [:end_headers]
       end
 
@@ -822,8 +831,8 @@ RSpec.describe HTTP2::Stream do
           expect(order).to eq [:reserved, :active, :half_close, :close]
         end
 
-        it 'client: headers > active > headers > .. > data > close' do
-          order, headers = [], []
+        it 'client: promise_headers > active > headers > .. > data > close' do
+          order, headers, promise_headers = [], [], []
           @client.on(:promise) do |push|
             order << :reserved
 
@@ -832,6 +841,10 @@ RSpec.describe HTTP2::Stream do
             push.on(:half_close) { order << :half_close }
             push.on(:close)     { order << :close }
 
+            push.on(:promise_headers) do |h|
+              order << :promise_headers
+              promise_headers += h
+            end
             push.on(:headers) do |h|
               order << :headers
               headers += h
@@ -845,10 +858,11 @@ RSpec.describe HTTP2::Stream do
             push.data('somedata')
           end
 
-          expect(headers).to eq([%w(key val), %w(key2 val2)])
+          expect(promise_headers).to eq([%w(key val)])
+          expect(headers).to eq([%w(key2 val2)])
           expect(order).to eq [
             :reserved,
-            :headers,
+            :promise_headers,
             :active,
             :headers,
             :half_close,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http-2
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.9.0
 platform: ruby
 authors:
 - Ilya Grigorik
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-09 00:00:00.000000000 Z
+date: 2018-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,7 @@ files:
 - example/keys/server.crt
 - example/keys/server.key
 - example/server.rb
+- example/upgrade_client.rb
 - example/upgrade_server.rb
 - http-2.gemspec
 - lib/http/2.rb