http-2 0.8.4 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: df6b5bd32b2217bebfb3205cfab1bd78f2a5456d
-  data.tar.gz: eb9d683a528819195bf81d4480549b2d8ac7bab6
+SHA256:
+  metadata.gz: 8dd78ba6a3468b6a3ceda2ebabc37ceb895a90d675d9fecc035b74d2f479a457
+  data.tar.gz: d70542d69e57050ab9ee3c837b6123fea81424a03bf3b99ffdc889a54a2fd20c
 SHA512:
-  metadata.gz: 686e87ef8beeedd1f3ac1371845b759687231ba62e3bab532d3d15d65febc179bc19f44d4a025708ecc62e2f0e7dd0689cfbbeef19e47c8ee52df9d050066228
-  data.tar.gz: 41b003cfeb4a127efcf9d4709167db3ff40934a175a08bd19d23a3874d6dd7e615f99ab967c5b85b521e54a4cdbfce33b4087c6ddde7eebd0d0fc11d18a4d551
+  metadata.gz: f678316f6235ed93ce5a3902ef3bf4c48854605de0875054d1f3e05196fc161bdfe49d149ff930413bef5ca76c61ab2d193092867a383f1f5dbe309cfef0f012
+  data.tar.gz: 52fce71379a9299df1cd8c93d44964d668d09c199564482193513b109a6339f220b4ae1e724c5965892b3e53855820a810e95405b8eb198797ea130611d39a05

data/.rspec

@@ -2,3 +2,4 @@ autotest
 --color
 --format documentation
 --order rand
+--warnings

data/.rubocop.yml

@@ -8,25 +8,42 @@ AllCops:
     - 'vendor/**/*'
     - '**/huffman_statemachine.rb'
 
+Layout/IndentHeredoc:
+  Exclude:
+    - 'lib/tasks/generate_huffman_table.rb'
+    - 'example/*'
+
 Metrics/LineLength:
   Max: 120
 
-Lint/EndAlignment:
-  AlignWith: variable
+Metrics/BlockLength:
+  Max: 700
+
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: variable
 
-Style/CaseIndentation:
-  IndentWhenRelativeTo: end
+Layout/CaseIndentation:
+  EnforcedStyle: end
 
-Style/IndentHash:
+Layout/IndentHash:
   EnforcedStyle: consistent
 
-Style/TrailingCommaInLiteral:
+Style/TrailingCommaInArrayLiteral:
   EnforcedStyleForMultiline: comma
 
-Style/SpaceAroundOperators:
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+Layout/SpaceAroundOperators:
   Enabled: false
 
-Style/ExtraSpacing:
+Layout/ExtraSpacing:
+  Enabled: false
+
+Layout/EmptyLinesAroundExceptionHandlingKeywords:
+  Enabled: false
+
+Naming/UncommunicativeMethodParamName:
   Enabled: false
 
 Style/SignalException:
@@ -44,14 +61,33 @@ Style/ParenthesesAroundCondition:
 Style/IfInsideElse:
   Enabled: false
 
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/MultilineIfModifier:
+  Enabled: false
+
+Lint/EmptyWhen:
+  Enabled: false
+
 Style/TrailingCommaInArguments:
   Enabled: false
 
 Style/TrailingUnderscoreVariable:
   Enabled: false
 
+Style/SymbolArray:
+  Enabled: false
+
+Style/CommentedKeyword:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
 Performance/TimesMap:
   Enabled: false
 
 Performance/RedundantBlockCall:
   Enabled: false
+

data/.rubocop_todo.yml

@@ -19,6 +19,9 @@ Metrics/BlockNesting:
 Metrics/ClassLength:
   Max: 325
 
+Metrics/ModuleLength:
+  Max: 120
+
 # Offense count: 12
 Metrics/CyclomaticComplexity:
   Max: 60
@@ -37,7 +40,7 @@ Metrics/MethodLength:
 # Offense count: 1
 # Configuration parameters: CountKeywordArgs.
 Metrics/ParameterLists:
-  Max: 6
+  Max: 7
 
 # Offense count: 10
 Metrics/PerceivedComplexity:
@@ -75,14 +78,14 @@ Style/GuardClause:
 # Cop supports --auto-correct.
 # Configuration parameters: SupportedStyles, IndentationWidth.
 # SupportedStyles: special_inside_parentheses, consistent, align_brackets
-Style/IndentArray:
+Layout/IndentArray:
   EnforcedStyle: consistent
 
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, SupportedStyles.
 # SupportedStyles: symmetrical, new_line, same_line
-Style/MultilineArrayBraceLayout:
+Layout/MultilineArrayBraceLayout:
   Exclude:
     - 'spec/compressor_spec.rb'
 
@@ -90,7 +93,7 @@ Style/MultilineArrayBraceLayout:
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, SupportedStyles.
 # SupportedStyles: symmetrical, new_line, same_line
-Style/MultilineHashBraceLayout:
+Layout/MultilineHashBraceLayout:
   Exclude:
     - 'spec/compressor_spec.rb'
 

data/.travis.yml

@@ -5,7 +5,7 @@ rvm:
   - 2.2
   - 2.3.0
   - 2.4.0
-  - jruby-9.1.8.0
+  - jruby-9.2.0.0 # latest stable
   - jruby-head
   - rbx-2
 matrix:

data/Gemfile

@@ -10,7 +10,7 @@ group :test do
   gem 'pry-byebug', platform: :mri
   gem 'rspec', '~> 3.4.0'
   gem 'rspec-autotest'
-  gem 'rubocop', '0.43.0'
+  gem 'rubocop', '0.57.2'
 end
 
 gemspec

data/Guardfile

@@ -1,4 +1,3 @@
-
 guard :process, name: 'HTTP/2 Server', command: 'ruby example/server.rb', stop_signal: 'TERM' do
   watch(%r{^example/(.+)\.rb$})
   watch(%r{^lib/http/2/(.+)\.rb$})

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 Ilya Grigorik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,16 +1,16 @@
 # HTTP-2
 
-[![Gem Version](https://badge.fury.io/rb/http-2.png)](http://rubygems.org/gems/http-2)
-[![Build Status](https://travis-ci.org/igrigorik/http-2.png?branch=master)](https://travis-ci.org/igrigorik/http-2)
-[![Coverage Status](https://coveralls.io/repos/igrigorik/http-2/badge.png)](https://coveralls.io/r/igrigorik/http-2)
+[![Gem Version](https://badge.fury.io/rb/http-2.svg)](http://rubygems.org/gems/http-2)
+[![Build Status](https://travis-ci.org/igrigorik/http-2.svg?branch=master)](https://travis-ci.org/igrigorik/http-2)
+[![Coverage Status](https://coveralls.io/repos/igrigorik/http-2/badge.svg)](https://coveralls.io/r/igrigorik/http-2)
 [![Analytics](https://ga-beacon.appspot.com/UA-71196-10/http-2/readme)](https://github.com/igrigorik/ga-beacon)
 
 Pure Ruby, framework and transport agnostic, implementation of HTTP/2 protocol and HPACK header compression with support for:
 
-* [Binary framing](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_binary_framing_layer) parsing and encoding
-* [Stream multiplexing](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_STREAMS_MESSAGES_FRAMES) and [prioritization](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PRIORITIZATION)
-* Connection and stream [flow control](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_flow_control)
-* [Header compression](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_HEADER_COMPRESSION) and [server push](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PUSH)
+* [Binary framing](https://hpbn.co/http2/#binary-framing-layer) parsing and encoding
+* [Stream multiplexing](https://hpbn.co/http2/#streams-messages-and-frames) and [prioritization](https://hpbn.co/http2/#stream-prioritization)
+* Connection and stream [flow control](https://hpbn.co/http2/#flow-control)
+* [Header compression](https://hpbn.co/http2/#header-compression) and [server push](https://hpbn.co/http2/#server-push)
 * Connection and stream management
 * And more... see [API docs](http://www.rubydoc.info/github/igrigorik/http-2/frames)
 
@@ -88,7 +88,7 @@ Events emitted by the connection object:
 
 ### Stream lifecycle management
 
-A single HTTP/2 connection can [multiplex multiple streams](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#REQUEST_RESPONSE_MULTIPLEXING) in parallel: multiple requests and responses can be in flight simultaneously and stream data can be interleaved and prioritized. Further, the specification provides a well-defined lifecycle for each stream (see below).
+A single HTTP/2 connection can [multiplex multiple streams](https://hpbn.co/http2/#request-and-response-multiplexing) in parallel: multiple requests and responses can be in flight simultaneously and stream data can be interleaved and prioritized. Further, the specification provides a well-defined lifecycle for each stream (see below).
 
 The good news is, all of the stream management, and state transitions, and error checking is handled by the library. All you have to do is subscribe to appropriate events (marked with ":" prefix in diagram below) and provide your application logic to handle request and response processing.
 
@@ -186,7 +186,7 @@ Events emitted by the [Stream object](http://www.rubydoc.info/github/igrigorik/h
 
 ### Prioritization
 
-Each HTTP/2 [stream has a priority value](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PRIORITIZATION) that can be sent when the new stream is initialized, and optionally reprioritized later:
+Each HTTP/2 [stream has a priority value](https://hpbn.co/http2/#stream-prioritization) that can be sent when the new stream is initialized, and optionally reprioritized later:
 
 ```ruby
 client = HTTP2::Client.new
@@ -203,7 +203,7 @@ On the opposite side, the server can optimize its stream processing order or res
 
 ### Flow control
 
-Multiplexing multiple streams over the same TCP connection introduces contention for shared bandwidth resources. Stream priorities can help determine the relative order of delivery, but priorities alone are insufficient to control how the resource allocation is performed between multiple streams. To address this, HTTP/2 provides a simple mechanism for [stream and connection flow control](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_flow_control).
+Multiplexing multiple streams over the same TCP connection introduces contention for shared bandwidth resources. Stream priorities can help determine the relative order of delivery, but priorities alone are insufficient to control how the resource allocation is performed between multiple streams. To address this, HTTP/2 provides a simple mechanism for [stream and connection flow control](https://hpbn.co/http2/#flow-control).
 
 Connection and stream flow control is handled by the library: all streams are initialized with the default window size (64KB), and send/receive window updates are automatically processed - i.e. window is decremented on outgoing data transfers, and incremented on receipt of window frames. Similarly, if the window is exceeded, then data frames are automatically buffered until window is updated.
 
@@ -219,16 +219,10 @@ stream.window              # check current window size
 stream.window_update(2048) # increment stream window by 2048 bytes
 ```
 
-Alternatively, flow control can be disabled by emitting an appropriate settings frame on the connection:
-
-```ruby
-# limit number of concurrent streams to 100 and disable flow control
-conn.settings(streams: 100, window: Float::INFINITY)
-```
 
 ### Server push
 
-An HTTP/2 server can [send multiple replies](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PUSH) to a single client request. To do so, first it emits a "push promise" frame which contains the headers of the promised resource, followed by the response to the original request, as well as promised resource payloads (which may be interleaved). A simple example is in order:
+An HTTP/2 server can [send multiple replies](https://hpbn.co/http2/#server-push) to a single client request. To do so, first it emits a "push promise" frame which contains the headers of the promised resource, followed by the response to the original request, as well as promised resource payloads (which may be interleaved). A simple example is in order:
 
 ```ruby
 conn = HTTP2::Server.new
@@ -276,10 +270,10 @@ conn.on(:promise) do |push|
 end
 ```
 
-The client can cancel any given push stream (via `.close`), or disable server push entirely by sending the appropriate settings frame (note that below setting only impacts server > client direction):
+The client can cancel any given push stream (via `.close`), or disable server push entirely by sending the appropriate settings frame:
 
 ```ruby
-client.settings(streams: 0) # setting max limit to 0 disables server push
+client.settings(settings_enable_push: 0)
 ```
 ### Specs
 

data/example/client.rb

@@ -55,6 +55,10 @@ conn.on(:frame_received) do |frame|
 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
@@ -110,7 +114,7 @@ while !sock.closed? && !sock.eof?
 
   begin
     conn << data
-  rescue => e
+  rescue StandardError => e
     puts "#{e.class} exception: #{e.message} - closing socket."
     e.backtrace.each { |l| puts "\t" + l }
     sock.close

data/example/server.rb

@@ -36,9 +36,7 @@ if options[:secure]
     DRAFT
   end
 
-  ctx.tmp_ecdh_callback = lambda do |*_args|
-    OpenSSL::PKey::EC.new 'prime256v1'
-  end
+  ctx.ecdh_curves = 'P-256'
 
   server = OpenSSL::SSL::SSLServer.new(server, ctx)
 end
@@ -132,7 +130,7 @@ loop do
 
     begin
       conn << data
-    rescue => e
+    rescue StandardError => e
       puts "#{e.class} exception: #{e.message} - closing socket."
       e.backtrace.each { |l| puts "\t" + l }
       sock.close

data/example/upgrade_client.rb

@@ -0,0 +1,153 @@
+# 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