http-2 0.11.0 → 1.0.0

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

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