h2 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b32f7af9ee3845b4a817610abf47cf8fdf4503fda1418b49ab323220fe1ccf49
-  data.tar.gz: 5a6fc19c1d0480c6f0eeddb808d61a09dbdb1582c4aa31125cbe6a8e4ba0b8a0
+  metadata.gz: 2b78f8a3e3aeed1884179c684adaa31e16cb377bdaa123d0af10f4cb174ff86f
+  data.tar.gz: 9beec3d11d01b4848118b17e1572275e231f580a48c62f0db28f52c059801c80
 SHA512:
-  metadata.gz: 20820c02ce3c3459deb468854498e3bf362c19d1b0f032979d77d679f44803bbd81db8d780714e428e192b9bbead83114da031af2c2b5f7983b79075345ced2c
-  data.tar.gz: 236e9658e69e7fde118c0cc4b679b2deceb83bebe2a06c4c33aac14038a39232d20ca4cadfc995e34a885b3c808dd14faee3cdb47e9adbca587b218ebeb00732
+  metadata.gz: 0ce8d9218b3cf9fc848ba56563ccdb8760cf63e30c312825ada05652e30dbcc60405109785b29c9466effcc9a3713ba8c57ccdf73c4a2f2b7984772e9a5f8f5a
+  data.tar.gz: ec1413ce8638d7aa6db8ec4e75f8032581e72dd391c5124e410ad3f9896feaf0f9580ae97895d846407d10e1b8a4a82ff381b57d14929d1d76240655ee55df53

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 h2 changelog
 ============
 
+### 0.8.1 11 aug 2018
+
+* update rake / bundler dep versions
+* refactors for interpreter warnings
+
 ### 0.8.0 10 aug 2018
 
 * fix read/settings ack race (https://httpwg.org/specs/rfc7540.html#ConnectionHeader)

data/Gemfile

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 
 gemspec
-gem 'http-2', path: '../http-2'
+# gem 'http-2', path: '../http-2'
 
 group :concurrent_ruby do
   gem 'concurrent-ruby'
@@ -14,7 +14,6 @@ end
 group :development, :test do
   gem 'awesome_print'
   gem 'certificate_authority'
-  gem 'guard-rake'
   gem 'pry-byebug', platforms: [:mri]
   gem 'celluloid-io', '~> 0.17', '>= 0.17.3'
 end

data/Rakefile

@@ -1,14 +1,28 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'fileutils'
+require File.expand_path '../test/support/create_certs', __FILE__
 
 task default: :test
 
-Rake::TestTask.new :test => ['test:certs'] do |t|
+Rake::TestTask.new :test do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
 namespace :test do
 
+  desc 'run tests via official ruby docker image'
+  task :docker, [:tag] do |_,args|
+    tag = args.fetch :tag, 'ruby:2.5'
+
+    FileUtils.mkdir_p 'tmp/docker'
+    system "docker pull #{tag}"
+    system "docker run --rm -v `pwd`:/opt/src/h2 -it #{tag} /bin/sh -c '" +
+           "cd /opt/src/h2 && " +
+           "bundle install --path tmp/docker && " +
+           "bundle exec rake test'"
+  end
+
   desc 'send TTIN signal to test process'
   task :ttin do
     pid = `ps -ef | grep -v grep | grep -e 'ruby.*_test\.rb' | awk '{print $2}'`.strip
@@ -18,19 +32,16 @@ namespace :test do
     end
   end
 
-  task :certs do
-    certs_dir = Pathname.new File.expand_path '../tmp/certs', __FILE__
-    ca_file = certs_dir.join('ca.crt').to_s
-    require_relative 'test/support/create_certs' unless File.exist? ca_file
-  end
+  task :nginx, [:tag, :ctx] do |_,args|
+    tag = args.fetch :tag, 'h2_nginx_http2'
+    ctx = args.fetch :ctx, 'test/support/nginx'
 
-  task :nginx => [:certs] do
-    system "docker build -t h2_nginx_http2 test/support/nginx"
+    system "docker build -t #{tag} #{ctx}"
     puts "\nstarting nginx with http/2 support"
-    puts "using document root: test/support/nginx/"
+    puts "using docker context/document root: #{ctx}"
     puts "using TLS certs: tmp/certs/server.*"
     puts "listening at https://localhost:4430/"
-    system "docker run --rm -v `pwd`/tmp/certs:/usr/local/nginx/certs -v `pwd`/test/support/nginx:/usr/local/nginx/html -p 4430:443 -it h2_nginx_http2"
+    system "docker run --rm -v `pwd`/tmp/certs:/usr/local/nginx/certs -v `pwd`/#{ctx}:/usr/local/nginx/html -p 4430:443 -it #{tag}"
   end
 
 end

data/examples/server/hello_world.rb

@@ -4,17 +4,48 @@
 require 'bundler/setup'
 require 'h2/server'
 
+# hello world example
+#
+# NOTE: this is a plaintext "h2c" type of HTTP/2 server. browsers probably will
+# never support this, but it may be useful for testing, or for behind
+# TLS-enabled proxies.
+
+# crank up the logger level for testing/example purposes
+#
 H2::Logger.level = ::Logger::DEBUG
-H2.verbose!
 
-addr, port = '127.0.0.1', 1234
+port = 1234
+addr = Socket.getaddrinfo('localhost', port).first[3]
+puts "*** Starting server on http://localhost:#{port}"
 
-puts "*** Starting server on http://#{addr}:#{port}"
+# create h2c server on the given address and port.
+# the constructor requires a block that will be called on each connection.
+#
 s = H2::Server::HTTP.new host: addr, port: port do |connection|
+
+  # each connection will have 0 or more streams, so we must give the
+  # connection a stream handler block via the +#each_stream+ method.
+  #
   connection.each_stream do |stream|
+
+    # here, without checking anything about the request, we respond with 200
+    # and a "hello, world\n" body
+    #
+    # see +H2::Server::Stream#respond+
+    #
     stream.respond status: 200, body: "hello, world!\n"
+
+    # since HTTP/2 connections are sort of intrinsically "keep-alive", we
+    # tell the client to close immediately with a GOAWAY frame
+    #
+    # see also +H2::Server::Connection#goaway_on_complete+
+    #
     stream.connection.goaway
+
   end
 end
 
+# now that our server reactor (Celluloid::IO instance) is configured and listening,
+# we can put the "main" thread to sleep.
+#
 sleep

data/examples/server/https_hello_world.rb

@@ -4,31 +4,76 @@
 require 'bundler/setup'
 require 'h2/server'
 
-port       = 1234
-addr       = Socket.getaddrinfo('localhost', port).first[3]
-certs_dir  = File.expand_path '../../../tmp/certs', __FILE__
+# hello world TLS example
+#
+# NOTE: this is a TLS-enabled "h2" type of HTTP/2 server. we will need some
+#       cryptography to get going. this will check for the existence of a git-
+#       ignored set of testing CA, server, and client certs/keys, creating
+#       them as needed.
+#
+#       see: test/support/create_certs.rb
+#
+require File.expand_path '../../../test/support/create_certs', __FILE__
+
+# crank up the logger level for testing/example purposes
+#
+H2::Logger.level = ::Logger::DEBUG
+
+port = 1234
+addr = Socket.getaddrinfo('localhost', port).first[3]
+puts "*** Starting server on https://localhost:#{port}"
 
 # if not using SNI, we may pass the underlying opts directly, and the same TLS
 # cert/key will be used for all incoming connections.
 #
+certs_dir = File.expand_path '../../../tmp/certs', __FILE__
 tls = {
   cert: certs_dir + '/server.crt',
   key:  certs_dir + '/server.key',
   # :extra_chain_cert => certs_dir + '/chain.pem'
 }
 
-puts "*** Starting server on https://#{addr}:#{port}"
-
+# create h2 server on the given address and port using the given certificate
+# and private key for all TLS negotiation. the constructor requires a block
+# that will be called on each connection.
+#
 s = H2::Server::HTTPS.new host: addr, port: port, **tls do |connection|
+
+  # each connection will have 0 or more streams, so we must give the
+  # connection a stream handler block via the +#each_stream+ method.
+  #
   connection.each_stream do |stream|
-    stream.goaway_on_complete
 
+    # check the request path (HTTP/2 psuedo-header ':path')
+    #
+    # see +H2::Server::Stream#request+ - access the +H2::Server::Stream::Request+ instance
+    #
     if stream.request.path == '/favicon.ico'
+
+      # since this is a TLS-enabled server, we could actually test it with a
+      # real browser, which will undoubtedly request /favicon.ico.
+      #
+      # see +H2::Server::Stream#respond+
+      #
       stream.respond status: 404
+
     else
+
+      # since HTTP/2 connections are sort of intrinsically "keep-alive", we
+      # tell the client to close when this stream is complete with a GOAWAY frame
+      #
+      stream.goaway_on_complete
+
+      # we respond with 200 and a "hello, world\n" body
+      #
+      # see +H2::Server::Stream#respond+
+      #
       stream.respond status: 200, body: "hello, world!\n"
     end
   end
 end
 
+# now that our server reactor (Celluloid::IO instance) is configured and listening,
+# we can put the "main" thread to sleep.
+#
 sleep

data/examples/server/push_promise.rb

@@ -4,53 +4,162 @@
 require 'bundler/setup'
 require 'h2/server'
 
+# push promise example
+#
+# NOTE: this is a TLS-enabled "h2" type of HTTP/2 server. we will need some
+#       cryptography to get going. this will check for the existence of a git-
+#       ignored set of testing CA, server, and client certs/keys, creating
+#       them as needed.
+#
+#       see: test/support/create_certs.rb
+#
+require File.expand_path '../../../test/support/create_certs', __FILE__
+
+# crank up the logger level for testing/example purposes
+#
 H2::Logger.level = ::Logger::DEBUG
-H2.verbose!
 
-port         = 4430
-addr         = '127.0.0.1' #Socket.getaddrinfo('localhost', port).first[3]
-certs_dir    = File.expand_path '../../../tmp/certs', __FILE__
-dog_png     = File.read File.expand_path '../dog.png', __FILE__
-push_promise = '<html><body>wait for it...<img src="/dog.png"/><script src="/pushed.js"></script></body></html>'
-pushed_js    = '(()=>{ alert("hello h2 push promise!"); })();'
+port = 1234
+addr = Socket.getaddrinfo('localhost', port).first[3]
+puts "*** Starting server on https://localhost:#{port}"
+
+# NOTE: since we're going to try a real-world push promise, let's load up some
+#       "useful" example bits to play with: full valid HTML, a PNG of a dog, and
+#       some javscript. we will respond directly with the HTML, but push promise
+#       the dog and js.
+#
+html = <<~EOHTML
+  <!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>HTTP/2 Push Promise Example</title>
+  </head>
+  <body>
+    wait for it...
+    <img src="/dog.png"/>
+    <script src="/pushed.js"></script>
+  </body>
+  </html>
+EOHTML
+
+dog_png_file = File.expand_path '../dog.png', __FILE__
+dog_png = File.read dog_png_file
+dog_png_fs = File::Stat.new dog_png_file
+dog_png_etag = OpenSSL::Digest::SHA.hexdigest dog_png_fs.ino.to_s +
+                                              dog_png_fs.size.to_s +
+                                              dog_png_fs.mtime.to_s
 
+pushed_js = '(()=>{ alert("hello h2 push promise!"); })();'
+
+# using SNI, we can negotiate TLS for multiple certificates based on the
+# requested servername.
+#
+# see: https://en.wikipedia.org/wiki/Server_Name_Indication
+# see: https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#servername_cb
+#
+certs_dir = File.expand_path '../../../tmp/certs', __FILE__
 sni = {
   'localhost' => {
     :cert => certs_dir + '/server.crt',
     :key  => certs_dir + '/server.key',
     # :extra_chain_cert => certs_dir + '/chain.pem'
   },
-  'vux.nakamura.io' => {
-    :cert => certs_dir + '/nakamuraio.crt',
-    :key  => certs_dir + '/nakamuraio.key',
-    :extra_chain_cert => certs_dir + '/nakamuraio-chain.pem'
+  'example.com' => {
+    :cert => certs_dir + '/example.com.crt',
+    :key  => certs_dir + '/example.com.key',
+    :extra_chain_cert => certs_dir + '/example.com-chain.pem'
   }
 }
 
-puts "*** Starting server on https://#{addr}:#{port}"
+# create h2 server on the given address and port using the given SNI +Hash+
+# for configuring TLS negotiation. the constructor requires a block that will
+# be called on each connection.
+#
 s = H2::Server::HTTPS.new host: addr, port: port, sni: sni do |connection|
+
+  # each connection will have 0 or more streams, so we must give the
+  # connection a stream handler block via the +#each_stream+ method.
+  #
   connection.each_stream do |stream|
 
+    # check the request path (HTTP/2 psuedo-header ':path')
+    #
+    # see +H2::Server::Stream#request+
+    #
     if stream.request.path == '/favicon.ico'
+
+      # since this is a TLS-enabled server, we could actually test it with a
+      # real browser, which will undoubtedly request /favicon.ico.
+      #
+      # see +H2::Server::Stream#respond+
+      #
       stream.respond status: 404
 
     else
+
+      # since HTTP/2 connections are sort of intrinsically "keep-alive", we
+      # tell the client to close when this stream is complete with a GOAWAY frame
+      #
       stream.goaway_on_complete
 
-      # one-line convenience with async "keep" handler
-      stream.push_promise path: '/dog.png', headers: { 'content-type' => 'image/png' }, body: dog_png
+      # initiate a push promise sub-stream, and queue the "keep" handler.
+      # since a push promise may be canceled, we queue the handler on the server reactor,
+      # after initiating the stream with headers, so that the client has a chance to
+      # cancel with a RST_STREAM frame.
+      #
+      # see +H2::Server::Stream#push_promise+
+      #
+      stream.push_promise path: '/dog.png',
+                          headers: {
+                            'content-type' => 'image/png',
+
+                            # NOTE: "etag" headers are not supplied by the server.
+                            #
+                            'etag' => dog_png_etag
+
+                          },
+                          body: dog_png
 
-      # more control over when promises are "kept"...
+      # instantiate a push promise sub-stream, but do not send initial headers
+      # nor "keep" the promise by sending the body.
+      #
+      # see +H2::Server::Stream#push_promise_for+
+      #
       js_promise = stream.push_promise_for path: '/pushed.js',
                                            headers: { 'content-type' => 'application/javascript' },
                                            body: pushed_js
+
+      # have this +H2::Server::PushPromise+ initiate the sub-stream on this
+      # stream by sending initial headers.
+      #
+      # see +H2::Server::PushPromise#make_on+
+      #
       js_promise.make_on stream
 
-      stream.respond status: 200, body: push_promise
+      # respond with 200 and HTML body
+      #
+      # see +H2::Server::Stream#respond+
+      #
+      stream.respond status: 200, body: html
 
+      # we have now waited until we've sent the entire body of the original
+      # response, so the client probably has received that and the push promise
+      # headers for both the dog and the script. our convenient +H2::Server::Stream#push_promise+
+      # method above queued the actual sending of the body on the server reactor,
+      # but for `js_promise`, we must keep it ourselves. in this case, we keep
+      # it "synchronously", but we may also call `#keep_async` to queue it.
+      #
+      # see +H2::Server::PushPromise#keep+
+      # see +H2::Server::PushPromise#keep_async+
+      #
       js_promise.keep
+
     end
   end
 end
 
+# now that our server reactor (Celluloid::IO instance) is configured and listening,
+# we can put the "main" thread to sleep.
+#
 sleep

data/examples/server/sse.rb

@@ -1,17 +1,35 @@
 #!/usr/bin/env ruby
-# Run with: bundle exec examples/server/sse/sse.rb
+# Run with: bundle exec examples/server/sse.rb
 
 require 'bundler/setup'
 require 'h2/server'
 
+# SSE / event source example
+#
+# NOTE: this is a TLS-enabled "h2" type of HTTP/2 server. we will need some
+#       cryptography to get going. this will check for the existence of a git-
+#       ignored set of testing CA, server, and client certs/keys, creating
+#       them as needed.
+#
+#       see: test/support/create_certs.rb
+#
+require File.expand_path '../../../test/support/create_certs', __FILE__
+
+# crank up the logger level for testing/example purposes
+#
 H2::Logger.level = ::Logger::DEBUG
-H2.verbose!
 
-port         = 4430
-addr         = Socket.getaddrinfo('localhost', port).first[3]
-certs_dir    = File.expand_path '../../../tmp/certs', __FILE__
-data, key    = Hash.new {|h,k| h[k] = ''}, nil
+port = 1234
+addr = Socket.getaddrinfo('localhost', port).first[3]
+puts "*** Starting server on https://localhost:#{port}"
 
+# using SNI, we can negotiate TLS for multiple certificates based on the
+# requested servername.
+#
+# see: https://en.wikipedia.org/wiki/Server_Name_Indication
+# see: https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#servername_cb
+#
+certs_dir    = File.expand_path '../../../tmp/certs', __FILE__
 sni = {
   'localhost' => {
     :cert => certs_dir + '/server.crt',
@@ -20,52 +38,145 @@ sni = {
   }
 }
 
+# this example is a bit more involved and requires more complicated
+# html and javascript. these two vars are the base for a "poor-man's"
+# implemenation of sinatra-style inline templates.
+#
+data, key = Hash.new {|h,k| h[k] = ''}, nil
+
+# for example purposes, we're just going to use a top-level array for
+# keeping track of connected +H2::Server::Stream::EventSource+ objects.
+#
+# NOTE: these are not "hijacked" sockets, like a websocket might be. since
+#       streams are multiplexed over one HTTP/2 TCP connection, each object
+#       only represents that stream, and should not hold up other streams
+#       on the connection.
+#
 event_sources = []
 
-puts "*** Starting server on https://#{addr}:#{port}"
+# create h2 server on the given address and port using the given SNI +Hash+
+# for configuring TLS negotiation. the constructor requires a block that will
+# be called on each connection.
+#
 s = H2::Server::HTTPS.new host: addr, port: port, sni: sni do |connection|
+
+  # each connection will have 0 or more streams, so we must give the
+  # connection a stream handler block via the +#each_stream+ method.
+  #
   connection.each_stream do |stream|
+
+    # check the request path (HTTP/2 psuedo-header ':path')
+    #
+    # see +H2::Server::Stream#request+
+    #
     case stream.request.path
     when '/favicon.ico'
+
+      # since this is a TLS-enabled server, we could actually test it with a
+      # real browser, which will undoubtedly request /favicon.ico.
+      #
+      # see +H2::Server::Stream#respond+
+      #
       stream.respond status: 404
 
     when '/events'
-      if stream.request.method == :delete
+
+      # check request method
+      #
+      case stream.request.method
+      when :get
+
+        # respond with headers turning this stream into an event source, and
+        # stash it in our top-level array.
+        #
+        # see +H2::Server::Stream#to_eventsource+
+        # see +H2::Server::Stream::EventSource+
+        #
+        begin
+          event_sources << stream.to_eventsource
+        rescue H2::Server::StreamError
+          stream.respond status: 400
+        end
+
+      when :delete
+
+        # handle a DELETE /events request by sending a final "die" event, then
+        # closing all connected event sources.
+        #
+        event_sources.each {|es| es.event name: 'die', data: 'later!' rescue nil }
         event_sources.each &:close
         event_sources.clear
+
+        # respond with the 200 "ok" status
+        #
         stream.respond status: 200
+
       else
-        event_sources << stream.to_eventsource
+        stream.respond status: 404
       end
 
     when '/msg'
+
+      # check to make sure this is a POST request
+      #
       if stream.request.method == :post
+
+        # handle a POST /msg request and send the received body to all
+        # connected event sources as the data of an event named "msg".
+        #
         msg = stream.request.body
-        event_sources.each {|es| es.event name: 'msg', data: msg}
+        event_sources.each {|es| es.event name: 'msg', data: msg rescue nil }
+
+        # respond with the 201 "created" status
+        #
         stream.respond status: 201
+
       else
+
+        # 404 if not post
+        #
         stream.respond status: 404
       end
 
     when '/sse.js'
+
+      # to further the push promise example a bit, here we respond with a 404
+      # if the client requests the script we've linked in the HTML. this means
+      # the *only* way for a client to get that script is to receive the push.
+      #
       stream.respond status: 404,
                      body: "should have been pushed..."
 
     else
+
+      # initiate a push promise sub-stream, and queue the "keep" handler.
+      # since a push promise may be canceled, we queue the handler on the server reactor,
+      # after initiating the stream with headers, so that the client has a chance to
+      # cancel with a RST_STREAM frame.
+      #
+      # see +H2::Server::Stream#push_promise+
+      #
       stream.push_promise path: '/sse.js',
                           headers: { 'content-type' => 'application/javascript' },
                           body: data[:javascript]
 
+      # respond with 200 and HTML body
+      #
+      # see +H2::Server::Stream#respond+
+      #
       stream.respond status: 200, body: data[:html]
+
     end
   end
 end
 
+# "poor-man's" sinatra-style inline "templates"
+#
 DATA.each_line do |l|
   if l.start_with?('@@')
     key = l.strip[2..-1].to_sym
   else
-    data[key] << l
+    data[key] << l unless l.empty?
   end
 end
 
@@ -86,18 +197,54 @@ __END__
   </form>
   <br/>
   <div><ol id="list"></ol></div>
+  <hr/>
+  <input id="delete" type="button" value="close all"/>
 </body>
 </html>
 
 @@javascript
+//
+// client code for SSE/eventsource example
+//
+var sse;
 document.addEventListener('DOMContentLoaded', () => {
-  let sse = new EventSource('/events');
+
+  // fire up a new EventSource instance. this will initiate the GET /events
+  // request with 'text/event-stream' accept header. it will also continue to
+  // try reconnecting if the connection closes enexpectedly.
+  //
+  sse = new EventSource('/events');
+
+  // add event listeners as normal client JS event handler functions, where the
+  // event "name" is the value given with the `name:` keyword to
+  // H2::Server::Stream::EventSource#event.
+  //
   sse.addEventListener('msg', (msg) => {
+
+    // in this case, we're listening for the "msg" event and simply adding a
+    // new item to the list already in the DOM with the given data.
+    //
     let item = document.createElement('li');
     item.innerHTML = msg.data;
     document.getElementById('list').appendChild(item);
   });
 
+  // since SSE will keep trying to reconnect, we want a way to signal a stop
+  // to that. listen for the "die" event and close the EventSource.
+  //
+  sse.addEventListener('die', (e) => {
+    console.log('got die event:', e.data);
+    sse.close();
+    console.log('closed:', sse);
+    document.getElementById('words').setAttribute('disabled', 'disabled');
+  });
+  document.getElementById('delete').onclick = (e) => {
+    fetch('/events', {method: 'delete'});
+  };
+
+  // for the sake of the example, we supply a input field/form and hijack
+  // the "submit" event to post it to our server.
+  //
   let w = document.getElementById('words');
   document.getElementById('say').onsubmit = (e) => {
     e.preventDefault();

data/exe/h2

@@ -5,7 +5,6 @@
 #
 # ---
 
-require 'colored'
 require 'optparse'
 
 begin # {{{
@@ -23,11 +22,13 @@ options = {
   debug: false,
   headers: {},
   goaway: false,
-  method: nil,
+  method: :get,
   tls: {},
   verbose: false
 }
 
+options[:tls][:ca_file] = ENV['H2_CAFILE'] if ENV['H2_CAFILE']
+
 OptionParser.new do |o|
 
   o.banner = 'Usage: h2 [options] URL'
@@ -36,7 +37,7 @@ OptionParser.new do |o|
     options[:block] = true
   end
 
-  o.on '--cafile [FILE]', String, 'certificate authority bundle' do |ca|
+  o.on '--cafile [FILE]', String, "certificate authority bundle (overrides ENV['H2_CAFILE'])" do |ca|
     raise ArgumentError, "invalid CA file: #{ca}" unless ca && File.exist?(ca)
     options[:tls][:ca_file] = ca
   end
@@ -72,6 +73,7 @@ OptionParser.new do |o|
   end
 
   o.on '-H [VALUE]', '--header [VALUE]', String, 'include header in request (format: "key: value")' do |h|
+    warn "psuedo-headers not supported via CLI" if h[0] == ':'
     kv = h.split(':').map &:strip
     options[:headers][kv[0]] = kv[1]
   end
@@ -86,16 +88,16 @@ OptionParser.new do |o|
     options[:method] = meth
   end
 
-  o.on '--version', 'print version information' do
-    puts "#{H2::USER_AGENT['user-agent']} using http-2-#{HTTP2::VERSION}"
+  o.on '-V', '--version', 'print version information' do
+    puts "#{H2::USER_AGENT['user-agent']}"
+    puts "  * http-2-#{HTTP2::VERSION}"
+    puts "  * #{OpenSSL::OPENSSL_VERSION}"
+    puts "  * CA file: #{options[:tls][:ca_file]}" if options[:tls][:ca_file]
     exit
   end
 
 end.parse!
 
-options[:method] ||= :get
-options[:tls][:ca_file] ||= ENV['H2_CAFILE'] if ENV['H2_CAFILE']
-
 # }}}
 
 # --- parse URL {{{
@@ -116,8 +118,8 @@ client[:tls] = options[:tls] unless options[:tls].empty?
 
 c = H2::Client.new **client do |c|
   if options[:debug]
-    c.client.on(:frame_received) {|f| puts "<< #{f.inspect}".yellow}
-    c.client.on(:frame_sent)     {|f| puts ">> #{f.inspect}".green}
+    c.client.on(:frame_received) {|f| puts "<< #{f.inspect}" }
+    c.client.on(:frame_sent)     {|f| puts ">> #{f.inspect}" }
   end
 end
 

data/h2.gemspec

@@ -1,5 +1,5 @@
 # coding: utf-8
-require_relative './lib/h2/version'
+require File.expand_path '../lib/h2/version', __FILE__
 
 Gem::Specification.new do |spec|
   spec.name          = "h2"
@@ -18,9 +18,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.2'
 
   spec.add_dependency 'http-2', '~> 0.10', '>= 0.10.0'
-  spec.add_dependency 'colored', '1.2'
 
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "minitest", "~> 5.0"
 end

data/lib/h2.rb

@@ -36,17 +36,6 @@ module H2
 
   class << self
 
-    # turn on extra verbose debug logging
-    #
-    def verbose!
-      @verbose = true
-    end
-
-    def verbose?
-      @verbose = false unless defined?(@verbose)
-      @verbose
-    end
-
     # convenience wrappers to make requests with HTTP methods
     #
     # @see H2.request
@@ -140,7 +129,6 @@ module H2
   module FrameDebugger
 
     def self.included base
-      H2.verbose!
       base::PARSER_EVENTS.push :frame_sent, :frame_received
     end
 

data/lib/h2/client.rb

@@ -66,29 +66,29 @@ module H2
     #
     def connect
       @socket = TCPSocket.new(@host, @port)
-      @socket = tls_socket @socket if @tls
+      @socket = tls_socket socket if @tls
       read
     end
 
     def connected?
-      !!@socket
+      !!socket
     end
 
     # @return true if the connection is closed
     #
     def closed?
-      connected? && @socket.closed?
+      connected? && socket.closed?
     end
 
     # close the connection
     #
     def close
       unblock!
-      @socket.close unless closed?
+      socket.close unless closed?
     end
 
     def eof?
-      @socket.eof?
+      socket.eof?
     end
 
     # send a goaway frame and wait until the connection is closed
@@ -204,7 +204,7 @@ module H2
     # maintain a ivar for the +Array+ to send to +IO.select+
     #
     def selector
-      @selector ||= [@socket]
+      @selector ||= [socket]
     end
 
     # creates a new +Thread+ to read the given number of bytes each loop from
@@ -268,7 +268,7 @@ module H2
     # @param [Integer] maxlen maximum number of bytes to read
     #
     def read_from_socket maxlen
-      @socket.read_nonblock maxlen
+      socket.read_nonblock maxlen
     rescue IO::WaitReadable
       :wait_readable
     end
@@ -290,12 +290,12 @@ module H2
     def on_frame bytes
       on :frame, bytes
 
-      if ::H2::Client::TCPSocket === @socket
+      if ::H2::Client::TCPSocket === socket
         total = bytes.bytesize
         loop do
           n = write_to_socket bytes
           if n == :wait_writable
-            IO.select nil, @socket.selector
+            IO.select nil, socket.selector
           elsif n < total
             bytes = bytes.byteslice n, total
           else
@@ -303,9 +303,9 @@ module H2
           end
         end
       else
-        @socket.write bytes
+        socket.write bytes
       end
-      @socket.flush
+      socket.flush
     end
 
     # frame_sent callback for parser: used to wait for initial settings frame
@@ -324,7 +324,7 @@ module H2
     # @param [String] bytes
     #
     def write_to_socket bytes
-      @socket.write_nonblock bytes
+      socket.write_nonblock bytes
     rescue IO::WaitWritable
       :wait_writable
     end
@@ -405,11 +405,11 @@ module H2
     module ExceptionlessIO
 
       def read_from_socket maxlen
-        @socket.read_nonblock maxlen, exception: false
+        socket.read_nonblock maxlen, exception: false
       end
 
       def write_to_socket bytes
-        @socket.write_nonblock bytes, exception: false
+        socket.write_nonblock bytes, exception: false
       end
 
     end

data/lib/h2/server.rb

@@ -6,19 +6,6 @@ module H2
 
   CONTENT_LENGTH_KEY = 'content-length'
 
-  class << self
-
-    def alpn?
-      !jruby? && OpenSSL::OPENSSL_VERSION_NUMBER >= ALPN_OPENSSL_MIN_VERSION && RUBY_VERSION >= '2.3'
-    end
-
-    def jruby?
-      return @jruby if defined? @jruby
-      @jruby = RUBY_ENGINE == 'jruby'
-    end
-
-  end
-
   # base H2 server, a +Celluoid::IO+ production
   #
   class Server

data/lib/h2/server/connection.rb

@@ -27,11 +27,15 @@ module H2
         @parser   = ::HTTP2::Server.new
         @attached = true
 
+        # set a default stream handler that raises +NotImplementedError+
+        #
+        @each_stream = ->(s){ raise NotImplementedError }
+
         yield self if block_given?
 
         bind_events
 
-        Logger.debug "new H2::Connection: #{self}" if H2.verbose?
+        Logger.debug "new H2::Connection: #{self}"
       end
 
       # is this connection still attached to the server reactor?
@@ -94,7 +98,7 @@ module H2
 
         rescue => e
           Logger.error "Exception: #{e.message} - closing socket"
-          STDERR.puts e.backtrace if H2.verbose?
+          STDERR.puts e.backtrace if H2::Logger.level == ::Logger::DEBUG
           close
 
         end

data/lib/h2/server/stream.rb

@@ -24,7 +24,8 @@ module H2
         :data
       ]
 
-      attr_reader :connection,
+      attr_reader :complete,
+                  :connection,
                   :push_promises,
                   :request,
                   :response,
@@ -62,7 +63,7 @@ module H2
       # task on the reactor to deliver the data
       #
       def push_promise *args
-        pp = push_promise_for *args
+        pp = push_promise_for(*args)
         make_promise pp
         @connection.server.async.handle_push_promise pp
       end
@@ -95,7 +96,7 @@ module H2
         if block
           @complete = block
         elsif @completed = (@responded and push_promises_complete?)
-          @complete[] if Proc === @complete
+          @complete[] if Proc === complete
           true
         else
           false
@@ -149,14 +150,14 @@ module H2
       # called by +@stream+ when this stream is activated
       #
       def on_active
-        log :debug, 'active' if H2.verbose?
+        log :debug, 'active'
         @request = H2::Server::Stream::Request.new self
       end
 
       # called by +@stream+ when this stream is closed
       #
       def on_close
-        log :debug, 'close' if H2.verbose?
+        log :debug, 'close'
         on_complete
         @closed = true
       end
@@ -165,14 +166,14 @@ module H2
       #
       def on_headers h
         incoming_headers = Hash[h]
-        log :debug, "headers: #{incoming_headers}" if H2.verbose?
+        log :debug, "headers: #{incoming_headers}"
         @request.headers.merge! incoming_headers
       end
 
       # called by +@stream+ with a +String+ body part
       #
       def on_data d
-        log :debug, "data: <<#{d}>>" if H2.verbose?
+        log :debug, "data: <<#{d}>>"
         @request.body << d
       end
 
@@ -180,7 +181,7 @@ module H2
       # is ready for response(s)
       #
       def on_half_close
-        log :debug, 'half_close' if H2.verbose?
+        log :debug, 'half_close'
         connection.server.async.handle_stream self
       end
 

data/lib/h2/server/stream/event_source.rb

@@ -45,7 +45,7 @@ module H2
         def init_response
           headers = SSE_HEADER.merge @headers
           @parser.headers stringify_headers(headers)
-        rescue ::HTTP2::Error::StreamClosed => sc
+        rescue ::HTTP2::Error::StreamClosed
           @stream.log :warn, "stream closed early by client"
         end
 

data/lib/h2/server/stream/request.rb

@@ -35,7 +35,7 @@ module H2
         # retreive the HTTP method as a lowercase +Symbol+
         #
         def method
-          return @method unless @method.nil?
+          return @method if defined? @method
           @method = headers[METHOD_KEY]
           @method = @method.downcase.to_sym if @method
           @method

data/lib/h2/server/stream/response.rb

@@ -62,7 +62,7 @@ module H2
           else
             stream.log :error, "unexpected @body: #{caller[0]}"
           end
-        rescue ::HTTP2::Error::StreamClosed => sc
+        rescue ::HTTP2::Error::StreamClosed
           stream.log :warn, "stream closed early by client"
         end
 

data/lib/h2/stream.rb

@@ -11,7 +11,7 @@ module H2
       :data
     ]
 
-    attr_reader :body, :client, :headers, :parent, :pushes, :stream
+    attr_reader :client, :parent, :pushes, :stream
 
     # create a new h2 stream
     #

data/lib/h2/version.rb

@@ -1,5 +1,5 @@
 module H2
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
 
   class << self
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h2
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Kenichi Nakamura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-10 00:00:00.000000000 Z
+date: 2018-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -30,48 +30,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.10.0
-- !ruby/object:Gem::Dependency
-  name: colored
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -99,7 +85,6 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile

data/Guardfile

@@ -1,3 +0,0 @@
-guard :rake, task: 'test' do
-  watch %r{^(lib|test).*}
-end