http-2 0.10.2 → 0.12.0

data/example/upgrade_server.rb

@@ -1,203 +0,0 @@
-# frozen_string_literals: true
-
-require_relative 'helper'
-require 'http_parser'
-
-options = { port: 8080 }
-OptionParser.new do |opts|
-  opts.banner = 'Usage: server.rb [options]'
-
-  opts.on('-s', '--secure', 'HTTPS mode') do |v|
-    options[:secure] = v
-  end
-
-  opts.on('-p', '--port [Integer]', 'listen port') do |v|
-    options[:port] = v
-  end
-end.parse!
-
-puts "Starting server on port #{options[:port]}"
-server = TCPServer.new(options[:port])
-
-if options[:secure]
-  ctx = OpenSSL::SSL::SSLContext.new
-  ctx.cert = OpenSSL::X509::Certificate.new(File.open('keys/server.crt'))
-  ctx.key = OpenSSL::PKey::RSA.new(File.open('keys/server.key'))
-  ctx.npn_protocols = [DRAFT]
-
-  server = OpenSSL::SSL::SSLServer.new(server, ctx)
-end
-
-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
-
-class UpgradeHandler
-  VALID_UPGRADE_METHODS = %w(GET OPTIONS).freeze
-  UPGRADE_RESPONSE = <<RESP.freeze
-HTTP/1.1 101 Switching Protocols
-Connection: Upgrade
-Upgrade: h2c
-
-RESP
-
-  attr_reader :complete, :headers, :body, :parsing
-
-  def initialize(conn, sock)
-    @conn, @sock = conn, sock
-    @complete, @parsing = false, false
-    @headers = request_header_hash
-    @body = ''
-    @parser = ::HTTP::Parser.new(self)
-  end
-
-  def <<(data)
-    @parsing ||= true
-    @parser << data
-    return unless complete
-
-    @sock.write UPGRADE_RESPONSE
-
-    settings = headers['http2-settings']
-    request = {
-      ':scheme'    => 'http',
-      ':method'    => @parser.http_method,
-      ':authority' => headers['Host'],
-      ':path'      => @parser.request_url,
-    }.merge(headers)
-
-    @conn.upgrade(settings, request, @body)
-  end
-
-  def complete!
-    @complete = true
-  end
-
-  def on_headers_complete(headers)
-    @headers.merge! headers
-  end
-
-  def on_body(chunk)
-    @body << chunk
-  end
-
-  def on_message_complete
-    fail unless VALID_UPGRADE_METHODS.include?(@parser.http_method)
-    @parsing = false
-    complete!
-  end
-end
-
-loop do
-  sock = server.accept
-  puts 'New TCP connection!'
-
-  conn = HTTP2::Server.new
-  conn.on(:frame) do |bytes|
-    # puts "Writing bytes: #{bytes.unpack("H*").first}"
-    sock.write bytes
-  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
-
-  conn.on(:stream) do |stream|
-    log = Logger.new(stream.id)
-    req = request_header_hash
-    buffer = ''
-
-    stream.on(:active) { log.info 'client opened new stream' }
-    stream.on(:close) do
-      log.info 'stream closed'
-    end
-
-    stream.on(:headers) do |h|
-      req.merge! Hash[*h.flatten]
-      log.info "request headers: #{h}"
-    end
-
-    stream.on(:data) do |d|
-      log.info "payload chunk: <<#{d}>>"
-      buffer << d
-    end
-
-    stream.on(:half_close) do
-      log.info 'client closed its end of the stream'
-
-      if req['Upgrade']
-        log.info "Processing h2c Upgrade request: #{req}"
-        if req[':method'] != 'OPTIONS' # Don't respond to OPTIONS...
-          response = 'Hello h2c world!'
-          stream.headers({
-            ':status' => '200',
-            'content-length' => response.bytesize.to_s,
-            'content-type' => 'text/plain',
-          }, end_stream: false)
-          stream.data(response)
-        end
-      else
-
-        response = nil
-        if req[':method'] == 'POST'
-          log.info "Received POST request, payload: #{buffer}"
-          response = "Hello HTTP 2.0! POST payload: #{buffer}"
-        else
-          log.info 'Received GET request'
-          response = 'Hello HTTP 2.0! GET request'
-        end
-
-        stream.headers({
-          ':status' => '200',
-          'content-length' => response.bytesize.to_s,
-          'content-type' => 'text/plain',
-        }, end_stream: false)
-
-        # split response into multiple DATA frames
-        stream.data(response.slice!(0, 5), end_stream: false)
-        stream.data(response)
-      end
-    end
-  end
-
-  uh = UpgradeHandler.new(conn, sock)
-
-  while !sock.closed? && !(sock.eof? rescue true) # rubocop:disable Style/RescueModifier
-    data = sock.readpartial(1024)
-    # puts "Received bytes: #{data.unpack("H*").first}"
-
-    begin
-      case
-      when !uh.parsing && !uh.complete
-
-        if data.start_with?(*UpgradeHandler::VALID_UPGRADE_METHODS)
-          uh << data
-        else
-          uh.complete!
-          conn << data
-        end
-
-      when uh.parsing && !uh.complete
-        uh << data
-
-      when uh.complete
-        conn << data
-      end
-
-    rescue StandardError => e
-      puts "Exception: #{e}, #{e.message} - closing socket."
-      puts e.backtrace.last(10).join("\n")
-      sock.close
-    end
-  end
-end
-
-# echo foo=bar | nghttp -d - -t 0 -vu http://127.0.0.1:8080/
-# nghttp -vu http://127.0.0.1:8080/

data/http-2.gemspec

@@ -1,22 +0,0 @@
-lib = File.expand_path('./lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'http/2/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'http-2'
-  spec.version       = HTTP2::VERSION
-  spec.authors       = ['Ilya Grigorik', 'Kaoru Maeda']
-  spec.email         = ['ilya@igvita.com']
-  spec.description   = 'Pure-ruby HTTP 2.0 protocol implementation'
-  spec.summary       = spec.description
-  spec.homepage      = 'https://github.com/igrigorik/http-2'
-  spec.license       = 'MIT'
-  spec.required_ruby_version = '>=2.1.0'
-
-  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'bundler'
-end

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