http-2 0.11.0 → 1.0.0

data/lib/tasks/generate_huffman_table.rb

@@ -1,166 +0,0 @@
-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.zero?
-        @emit = chr
-      else
-        bit = (code & (1 << (len - 1))).zero? ? 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)).zero? ? 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

@@ -1,28 +0,0 @@
-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 force 8-bit encoding when adding data' do
-    b << 'émalgré'
-    expect(b.encoding.to_s).to eq 'ASCII-8BIT'
-    b.prepend('émalgré')
-    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

@@ -1,188 +0,0 @@
-require 'helper'
-
-RSpec.describe HTTP2::Client do
-  include FrameHelpers
-  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
-
-    it 'should initialize client when receiving server settings before sending ack' do
-      frames = []
-      @client.on(:frame) { |bytes| frames << bytes }
-      @client << f.generate(settings_frame)
-
-      expect(frames[0]).to eq CONNECTION_PREFACE_MAGIC
-      expect(f.parse(frames[1])[:type]).to eq :settings
-      ack_frame = f.parse(frames[2])
-      expect(ack_frame[:type]).to eq :settings
-      expect(ack_frame[:flags]).to include(:ack)
-    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
-        @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_frame), 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_frame), 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_frame
-
-        @client << set_stream_id(f.generate(push_promise_frame), s.id)
-        @client << set_stream_id(f.generate(push_promise_frame), 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_frame
-
-      promise = nil
-      @client.on(:promise) { |stream| promise = stream }
-      @client << set_stream_id(f.generate(push_promise_frame), 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_frame
-
-      @client.on(:promise) do |stream|
-        stream.on(:promise_headers) do |h|
-          header = h
-        end
-      end
-      @client << set_stream_id(f.generate(push_promise_frame), 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_frame
-      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_frame), s.id)
-    end
-  end
-
-  context 'alt-svc' do
-    context 'received in the connection' do
-      it 'should emit :altsvc when receiving one' do
-        @client << f.generate(settings_frame)
-        frame = nil
-        @client.on(:altsvc) do |f|
-          frame = f
-        end
-        @client << f.generate(altsvc_frame)
-        expect(frame).to be_a(Hash)
-      end
-      it 'should not emit :altsvc when the frame when contains no host' do
-        @client << f.generate(settings_frame)
-        frame = nil
-        @client.on(:altsvc) do |f|
-          frame = f
-        end
-
-        @client << f.generate(altsvc_frame.merge(origin: nil))
-        expect(frame).to be_nil
-      end
-    end
-    context 'received in a stream' do
-      it 'should emit :altsvc' do
-        s = @client.new_stream
-        s.send headers_frame
-        s.close
-
-        frame = nil
-        s.on(:altsvc) { |f| frame = f }
-
-        @client << set_stream_id(f.generate(altsvc_frame.merge(origin: nil)), s.id)
-
-        expect(frame).to be_a(Hash)
-      end
-      it 'should not emit :alt_svc when the frame when contains a origin' do
-        s = @client.new_stream
-        s.send headers_frame
-        s.close
-
-        frame = nil
-        s.on(:altsvc) { |f| frame = f }
-
-        @client << set_stream_id(f.generate(altsvc_frame), s.id)
-
-        expect(frame).to be_nil
-      end
-    end
-  end
-end