mieps_http-2 0.8.0

data/lib/http/2/version.rb

@@ -0,0 +1,3 @@
+module HTTP2
+  VERSION = '0.8.0'.freeze
+end

data/lib/http/2.rb

@@ -0,0 +1,13 @@
+require 'http/2/version'
+require 'http/2/error'
+require 'http/2/emitter'
+require 'http/2/buffer'
+require 'http/2/flow_buffer'
+require 'http/2/huffman'
+require 'http/2/huffman_statemachine'
+require 'http/2/compressor'
+require 'http/2/framer'
+require 'http/2/connection'
+require 'http/2/client'
+require 'http/2/server'
+require 'http/2/stream'

data/lib/tasks/generate_huffman_table.rb

@@ -0,0 +1,166 @@
+desc 'Generate Huffman precompiled table in huffman_statemachine.rb'
+task :generate_table do
+  HuffmanTable::Node.generate_state_table
+end
+
+require_relative '../http/2/huffman'
+
+# @private
+module HuffmanTable
+  BITS_AT_ONCE = HTTP2::Header::Huffman::BITS_AT_ONCE
+  EOS          = 256
+
+  class Node
+    attr_accessor :next, :emit, :final, :depth
+    attr_accessor :transitions
+    attr_accessor :id
+    @@id = 0 # rubocop:disable Style/ClassVars
+    def initialize(depth)
+      @next = [nil, nil]
+      @id = @@id
+      @@id += 1 # rubocop:disable Style/ClassVars
+      @final = false
+      @depth = depth
+    end
+
+    def add(code, len, chr)
+      self.final = true if chr == EOS && @depth <= 7
+      if len == 0
+        @emit = chr
+      else
+        bit = (code & (1 << (len - 1))) == 0 ? 0 : 1
+        node = @next[bit] ||= Node.new(@depth + 1)
+        node.add(code, len - 1, chr)
+      end
+    end
+
+    class Transition
+      attr_accessor :emit, :node
+      def initialize(emit, node)
+        @emit = emit
+        @node = node
+      end
+    end
+
+    def self.generate_tree
+      @root = new(0)
+      HTTP2::Header::Huffman::CODES.each_with_index do |c, chr|
+        code, len = c
+        @root.add(code, len, chr)
+      end
+      puts "#{@@id} nodes"
+      @root
+    end
+
+    def self.generate_machine
+      generate_tree
+      togo = Set[@root]
+      @states = Set[@root]
+
+      until togo.empty?
+        node = togo.first
+        togo.delete(node)
+
+        next if node.transitions
+        node.transitions = Array[1 << BITS_AT_ONCE]
+
+        (1 << BITS_AT_ONCE).times do |input|
+          n = node
+          emit = ''
+          (BITS_AT_ONCE - 1).downto(0) do |i|
+            bit = (input & (1 << i)) == 0 ? 0 : 1
+            n = n.next[bit]
+            next unless n.emit
+            if n.emit == EOS
+              emit = EOS # cause error on decoding
+            else
+              emit << n.emit.chr(Encoding::BINARY) unless emit == EOS
+            end
+            n = @root
+          end
+          node.transitions[input] = Transition.new(emit, n)
+          togo << n
+          @states << n
+        end
+      end
+      puts "#{@states.size} states"
+      @root
+    end
+
+    def self.generate_state_table
+      generate_machine
+      state_id = {}
+      id_state = {}
+      state_id[@root] = 0
+      id_state[0] = @root
+      max_final = 0
+      id = 1
+      (@states - [@root]).sort_by { |s| s.final ? 0 : 1 }.each do |s|
+        state_id[s] = id
+        id_state[id] = s
+        max_final = id if s.final
+        id += 1
+      end
+
+      File.open(File.expand_path('../http/2/huffman_statemachine.rb', File.dirname(__FILE__)), 'w') do |f|
+        f.print <<HEADER
+# Machine generated Huffman decoder state machine.
+# DO NOT EDIT THIS FILE.
+
+# The following task generates this file.
+#   rake generate_huffman_table
+
+module HTTP2
+  module Header
+    class Huffman
+      # :nodoc:
+      MAX_FINAL_STATE = #{max_final}
+      MACHINE = [
+HEADER
+        id.times do |i|
+          n = id_state[i]
+          f.print '        ['
+          string = (1 << BITS_AT_ONCE).times.map do |t|
+            transition = n.transitions.fetch(t)
+            emit = transition.emit
+            unless emit == EOS
+              bytes = emit.bytes
+              fail ArgumentError if bytes.size > 1
+              emit = bytes.first
+            end
+            "[#{emit.inspect}, #{state_id.fetch(transition.node)}]"
+          end.join(', ')
+          f.print(string)
+          f.print "],\n"
+        end
+        f.print <<TAILER
+      ].each { |arr| arr.each { |subarr| subarr.each(&:freeze) }.freeze }.freeze
+    end
+  end
+end
+TAILER
+      end
+    end
+
+    class << self
+      attr_reader :root
+    end
+
+    # Test decoder
+    def self.decode(input)
+      emit = ''
+      n = root
+      nibbles = input.unpack('C*').flat_map { |b| [((b & 0xf0) >> 4), b & 0xf] }
+      until nibbles.empty?
+        nb = nibbles.shift
+        t = n.transitions[nb]
+        emit << t.emit
+        n = t.node
+      end
+      unless n.final && nibbles.all? { |x| x == 0xf }
+        puts "len = #{emit.size} n.final = #{n.final} nibbles = #{nibbles}"
+      end
+      emit
+    end
+  end
+end

data/spec/buffer_spec.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+RSpec.describe HTTP2::Buffer do
+  let(:b) { Buffer.new('émalgré') }
+
+  it 'should force 8-bit encoding' do
+    expect(b.encoding.to_s).to eq 'ASCII-8BIT'
+  end
+
+  it 'should return bytesize of the buffer' do
+    expect(b.size).to eq 9
+  end
+
+  it 'should read single byte at a time' do
+    9.times { expect(b.read(1)).not_to be_nil }
+  end
+
+  it 'should unpack an unsigned 32-bit int' do
+    expect(Buffer.new([256].pack('N')).read_uint32).to eq 256
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,92 @@
+require 'helper'
+
+RSpec.describe HTTP2::Client do
+  before(:each) do
+    @client = Client.new
+  end
+
+  let(:f) { Framer.new }
+
+  context 'initialization and settings' do
+    it 'should return odd stream IDs' do
+      expect(@client.new_stream.id).not_to be_even
+    end
+
+    it 'should emit connection header and SETTINGS on new client connection' do
+      frames = []
+      @client.on(:frame) { |bytes| frames << bytes }
+      @client.ping('12345678')
+
+      expect(frames[0]).to eq CONNECTION_PREFACE_MAGIC
+      expect(f.parse(frames[1])[:type]).to eq :settings
+    end
+
+    it 'should initialize client with custom connection settings' do
+      frames = []
+
+      @client = Client.new(settings_max_concurrent_streams: 200)
+      @client.on(:frame) { |bytes| frames << bytes }
+      @client.ping('12345678')
+
+      frame = f.parse(frames[1])
+      expect(frame[:type]).to eq :settings
+      expect(frame[:payload]).to include([:settings_max_concurrent_streams, 200])
+    end
+  end
+
+  context 'push' do
+    it 'should disallow client initiated push' do
+      expect do
+        @client.promise({}) {}
+      end.to raise_error(NoMethodError)
+    end
+
+    it 'should raise error on PUSH_PROMISE against stream 0' do
+      expect do
+        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 0)
+      end.to raise_error(ProtocolError)
+    end
+
+    it 'should raise error on PUSH_PROMISE against bogus stream' do
+      expect do
+        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 31_415)
+      end.to raise_error(ProtocolError)
+    end
+
+    it 'should raise error on PUSH_PROMISE against non-idle stream' do
+      expect do
+        s = @client.new_stream
+        s.send HEADERS
+
+        @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+        @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+      end.to raise_error(ProtocolError)
+    end
+
+    it 'should emit stream object for received PUSH_PROMISE' do
+      s = @client.new_stream
+      s.send HEADERS.deep_dup
+
+      promise = nil
+      @client.on(:promise) { |stream| promise = stream }
+      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+
+      expect(promise.id).to eq 2
+      expect(promise.state).to eq :reserved_remote
+    end
+
+    it 'should auto RST_STREAM promises against locally-RST stream' do
+      s = @client.new_stream
+      s.send HEADERS.deep_dup
+      s.close
+
+      allow(@client).to receive(:send)
+      expect(@client).to receive(:send) do |frame|
+        expect(frame[:type]).to eq :rst_stream
+        expect(frame[:stream]).to eq 2
+      end
+
+      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+    end
+  end
+end