http-2 0.10.2 → 0.12.0

data/Rakefile

@@ -1,49 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
-require 'yard'
-require 'open3'
-require_relative 'lib/tasks/generate_huffman_table'
-
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.exclude_pattern = './spec/hpack_test_spec.rb'
-end
-
-RSpec::Core::RakeTask.new(:hpack) do |t|
-  t.pattern = './spec/hpack_test_spec.rb'
-end
-
-task :h2spec do
-  if /darwin/ !~ RUBY_PLATFORM
-    abort "h2spec rake task currently only works on OSX.
-           Download other binaries from https://github.com/summerwind/h2spec/releases"
-  end
-
-  system 'ruby example/server.rb -p 9000 &', out: File::NULL
-  sleep 1
-
-  output = ''
-  Open3.popen2e('spec/h2spec/h2spec.darwin -p 9000 -o 1') do |_i, oe, _t|
-    oe.each do |l|
-      l.gsub!(/\e\[(\d+)(;\d+)*m/, '')
-
-      output << l
-      if l =~ /passed.*failed/
-        puts "\n#{l}"
-        break # suppress post-summary failure output
-      else
-        print '.'
-      end
-    end
-  end
-
-  File.write 'spec/h2spec/output/non_secure.txt', output
-
-  system 'kill `pgrep -f example/server.rb`'
-end
-
-RuboCop::RakeTask.new
-YARD::Rake::YardocTask.new
-
-task default: [:spec, :rubocop]
-task all: [:default, :hpack]

data/example/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'http_parser.rb'

data/example/README.md

@@ -1,44 +0,0 @@
-## Interop
-
-First, a quick test to ensure that we can talk to ourselves:
-
-```bash
-# Direct connection
-$> ruby server.rb
-$> ruby client.rb http://localhost:8080/                 # GET
-$> ruby client.rb http://localhost:8080/ -d 'some data'  # POST
-
-# Server push
-$> ruby server.rb --push
-$> ruby client.rb http://localhost:8080/                 # GET
-
-# TLS + NPN negotiation
-$> ruby server.rb --secure
-$> ruby client.rb https://localhost:8080/                # GET
-$> ...
-```
-
-### [nghttp2](https://github.com/tatsuhiro-t/nghttp2) (HTTP/2.0 C Library)
-
-Public test server: http://106.186.112.116 (Upgrade + Direct)
-
-```bash
-# Direct request (http-2 > nghttp2)
-$> ruby client.rb http://106.186.112.116/
-
-# TLS + NPN request (http-2 > nghttp2)
-$> ruby client.rb https://106.186.112.116/
-
-# Direct request (nghttp2 > http-2)
-$> ruby server.rb
-$> nghttp -vnu http://localhost:8080       # Direct request to Ruby server
-```
-
-### Twitter (Java server)
-
-```bash
-# NPN + GET request (http-2 > twitter)
-$> ruby client.rb https://twitter.com/
-```
-
-For a complete list of current implementations, see [http2 wiki](https://github.com/http2/http2-spec/wiki/Implementations).

data/example/client.rb

@@ -1,122 +0,0 @@
-require_relative 'helper'
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = 'Usage: client.rb [options]'
-
-  opts.on('-d', '--data [String]', 'HTTP payload') do |v|
-    options[:payload] = v
-  end
-end.parse!
-
-uri = URI.parse(ARGV[0] || 'http://localhost:8080/')
-tcp = TCPSocket.new(uri.host, uri.port)
-sock = nil
-
-if uri.scheme == 'https'
-  ctx = OpenSSL::SSL::SSLContext.new
-  ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-  # For ALPN support, Ruby >= 2.3 and OpenSSL >= 1.0.2 are required
-
-  ctx.alpn_protocols = [DRAFT]
-  ctx.alpn_select_cb = lambda do |protocols|
-    puts "ALPN protocols supported by server: #{protocols}"
-    DRAFT if protocols.include? DRAFT
-  end
-
-  sock = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
-  sock.sync_close = true
-  sock.hostname = uri.hostname
-  sock.connect
-
-  if sock.alpn_protocol != DRAFT
-    puts "Failed to negotiate #{DRAFT} via ALPN"
-    exit
-  end
-else
-  sock = tcp
-end
-
-conn = HTTP2::Client.new
-stream = conn.new_stream
-log = Logger.new(stream.id)
-
-conn.on(:frame) do |bytes|
-  # puts "Sending bytes: #{bytes.unpack("H*").first}"
-  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
-
-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
-
-  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
-
-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
-
-head = {
-  ':scheme' => uri.scheme,
-  ':method' => (options[:payload].nil? ? 'GET' : 'POST'),
-  ':authority' => [uri.host, uri.port].join(':'),
-  ':path' => uri.path,
-  'accept' => '*/*',
-}
-
-puts 'Sending HTTP 2.0 request'
-if head[':method'] == 'GET'
-  stream.headers(head, end_stream: true)
-else
-  stream.headers(head, end_stream: false)
-  stream.data(options[:payload])
-end
-
-while !sock.closed? && !sock.eof?
-  data = sock.read_nonblock(1024)
-  # puts "Received bytes: #{data.unpack("H*").first}"
-
-  begin
-    conn << data
-  rescue StandardError => e
-    puts "#{e.class} exception: #{e.message} - closing socket."
-    e.backtrace.each { |l| puts "\t" + l }
-    sock.close
-  end
-end

data/example/helper.rb

@@ -1,19 +0,0 @@
-$LOAD_PATH << 'lib' << '../lib'
-
-require 'optparse'
-require 'socket'
-require 'openssl'
-require 'http/2'
-require 'uri'
-
-DRAFT = 'h2'.freeze
-
-class Logger
-  def initialize(id)
-    @id = id
-  end
-
-  def info(msg)
-    puts "[Stream #{@id}]: #{msg}"
-  end
-end

data/example/keys/server.crt

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDLjCCAhYCCQDIZ/9hq/2pXjANBgkqhkiG9w0BAQUFADBZMQswCQYDVQQGEwJB
-VTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0
-cyBQdHkgTHRkMRIwEAYDVQQDEwlsb2NhbGhvc3QwHhcNMTYwNjA2MTk0MzI1WhcN
-MTcwNjA2MTk0MzI1WjBZMQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0
-ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMRIwEAYDVQQDEwls
-b2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCjFXrWqtRZ
-EMOO/o6AxGbgDYMgg/7uxCFQJM5Z6C4II6D8V94FDyCd+J0LOK2hB+QUdFqpA1S9
-6RW2MvIwdvRt03RJMgbfcUF0+w4ZItv2xrW9waCfCmLSRDZgcSATacEF6u9p2Vs+
-o4J/cHacirSwjy4+m94CgkxtUFGtGcJaFqAZ6Cdj5WvQdJSiAI3x3gNC/UGA+5dL
-sp8+vwWx+/TMc6nDBmoRW3GHeG/NApQSh01w3wDv0FmUaFQlA5WPya/Js+CyuYh1
-miXbQJEjDnGGaJjnoyRAQpPrk72Jj+bnfOu9kxpzkuLJOsbaofRFkM+/Ar5U+bQz
-uU0ErQ8Ih8MPAgMBAAEwDQYJKoZIhvcNAQEFBQADggEBACL8HkKjW8kWLlW4TE5K
-EcfsBad2Ah5ugTocJ/pLnr/YEo8uD91gECDtsuFTXul9n2M7U5jJmzbHZ63cjyC3
-lb1BxJxUL7aIyaL61IMMcIJMWhC9VGnFUshMDNVBhuRkKs/QvaMD5KefKN1E9I2M
-mZ72Yww0VihYwNOu3MTn8gUuy9eU6k/gTYPY7PJVh18QmR+Fs2MaaPp+bDwxiqML
-0o2I6+0ZsqM3vFtcUjxjRASV5s+JkM34pTWFwUOl7TZv1YsxCKSz4f0BXDImZEvU
-rwqFdlELp5WOG9LJsrszDRbf1wbFUsG1XXZpIBiWo3d6pOiIyRKrak1vKViNfYvI
-W30=
------END CERTIFICATE-----

data/example/keys/server.key

@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEAoxV61qrUWRDDjv6OgMRm4A2DIIP+7sQhUCTOWeguCCOg/Ffe
-BQ8gnfidCzitoQfkFHRaqQNUvekVtjLyMHb0bdN0STIG33FBdPsOGSLb9sa1vcGg
-nwpi0kQ2YHEgE2nBBervadlbPqOCf3B2nIq0sI8uPpveAoJMbVBRrRnCWhagGegn
-Y+Vr0HSUogCN8d4DQv1BgPuXS7KfPr8Fsfv0zHOpwwZqEVtxh3hvzQKUEodNcN8A
-79BZlGhUJQOVj8mvybPgsrmIdZol20CRIw5xhmiY56MkQEKT65O9iY/m53zrvZMa
-c5LiyTrG2qH0RZDPvwK+VPm0M7lNBK0PCIfDDwIDAQABAoIBAQCZShphZsccRJ6c
-bPdDX9iW5vyG9qsMgPwTGdWAOrXx3pN2PZ0pwjNVaRcsMgU6JHGlLEz/Kmtf6pQG
-41I0bcuI48Yc+tHs+sadD1IMHHEHP3Yau8KfWyLSI129Pvf4Z2IQjuik5LJYaVbD
-NNG4iMQYZS0Bmn6Oey0dXu62t0ywYa0qvbIDse/RmjTQSTipuvGg8/QEAeRGABv8
-Nd4Esya0zuxk6hGaNp3hkjyRkeoC7RsBVJbFSnp6gSubPdXwrJyHfySKe9jvrDG3
-Q/AzyHUh/6EODd5n66x0p6rq7oo9/PnLvZJY8jIGWG+aEp68RJyEgimrwll0rAWw
-/buqijGRAoGBANimL8407fFirmct7BceavaeJfXPK5yWiOhVX0XlJ0phAFuaAxK3
-5HVT7DD+KKV66g1jtS9FUVZGDiYFHlsdsYuHVYcRmr0h5rZr941obrDwNrM9Nf9C
-0uehN5+n/FaeGoQLR3V4THoP3rlkYTlLpQnI5mKA19JukXnIiJM9ARUZAoGBAMC0
-mcVsVuSKSFwURtQHHIufxL6SqC2kLTwIQ7exqejNYPCqCiif+ZWOmsTqbVGAGbMK
-Ohak4oLwN5IGCl4jNQG+vWagREkx6OXSk5NYcfoNBrOm+0UoFRzoEA85s7Dy6PuD
-tBucNZpt1sGauzkCSx7C8jj4ZlSwkv0XhBFfbTZnAoGBAK2wBjF+U6iq4YFM2rLq
-KvzOa0Z3MdKXCOmiz//cKDTEMaI+heoyzZCWmIvqpzGLqirT3gUowH23Kk6m2eBY
-nOdst0/S+Eha7nkfc9bFe8CUxHXMRAcCTs1ufYadCXtzw3RLCp4NtNpC8N+Wry9d
-CtIeYz1jaCOHi0+kSoIobT65AoGAc6hxWkJp7ITqZQlucTdLdKmRheeztKEC3TMA
-obGqDqWldww3SKarP431ahZhQjcmNYT/1DNmF7xhPe0OL+3llISMXJn4Ig4ogDdg
-h2DgF3nV+eFQkfM6qLzHVrwFE0DXgI1NffzFV0hxSoW5tL+honbStkqv8EiCEBEb
-HOovPCUCgYBpXuPARd2ycInAulVHijJmj2rmK7f41ZhVCWovYjcCWyeJyLIO7j+b
-MBJZbmwpStJhEjW64nE2zZGWg2HCBbvZz5/SXIr3fp7qVXwpn1TvB/TJDf43t0oF
-3caLgyQYoQCsVHKT3cU4s3wuog/DyHKh9FtRkcJrEy7h9Rrc+ModbA==
------END RSA PRIVATE KEY-----

data/example/server.rb

@@ -1,139 +0,0 @@
-require_relative 'helper'
-
-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
-
-  opts.on('-u', '--push', 'Push message') do |_v|
-    options[:push] = true
-  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.ssl_version = :TLSv1_2
-  ctx.options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
-  ctx.ciphers = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-
-  ctx.alpn_protocols = ['h2']
-
-  ctx.alpn_select_cb = lambda do |protocols|
-    raise "Protocol #{DRAFT} is required" if protocols.index(DRAFT).nil?
-    DRAFT
-  end
-
-  ctx.ecdh_curves = 'P-256'
-
-  server = OpenSSL::SSL::SSLServer.new(server, ctx)
-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.is_a?(TCPSocket) ? sock.sendmsg(bytes) : 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, buffer = {}, ''
-
-    stream.on(:active) { log.info 'client opened new stream' }
-    stream.on(:close)  { log.info 'stream closed' }
-
-    stream.on(:headers) do |h|
-      req = 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'
-
-      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)
-
-      if options[:push]
-        push_streams = []
-
-        # send 10 promises
-        10.times do |i|
-          puts 'sending push'
-
-          head = { ':method' => 'GET',
-                   ':authority' => 'localhost',
-                   ':scheme' => 'https',
-                   ':path' => "/other_resource/#{i}" }
-
-          stream.promise(head) do |push|
-            push.headers(':status' => '200', 'content-type' => 'text/plain', 'content-length' => '11')
-            push_streams << push
-          end
-        end
-      end
-
-      # split response into multiple DATA frames
-      stream.data(response.slice!(0, 5), end_stream: false)
-      stream.data(response)
-
-      if options[:push]
-        push_streams.each_with_index do |push, i|
-          sleep 1
-          push.data("push_data #{i}")
-        end
-      end
-    end
-  end
-
-  while !sock.closed? && !(sock.eof? rescue true) # rubocop:disable Style/RescueModifier
-    data = sock.readpartial(1024)
-    # puts "Received bytes: #{data.unpack("H*").first}"
-
-    begin
-      conn << data
-    rescue StandardError => e
-      puts "#{e.class} exception: #{e.message} - closing socket."
-      e.backtrace.each { |l| puts "\t" + l }
-      sock.close
-    end
-  end
-end

data/example/upgrade_client.rb

@@ -1,153 +0,0 @@
-# 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(headers)
-    @headers.merge!(headers)
-    puts "received headers: #{headers}"
-  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 StandardError => e
-    puts "#{e.class} exception: #{e.message} - closing socket."
-    e.backtrace.each { |l| puts "\t" + l }
-    conn.close
-    sock.close
-  end
-end