h2 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09291052e9be6853fdbc3a57b31516e8a61b6a3a8a3e11e0d46215d4ec14cf7c'
-  data.tar.gz: a18029d8019099fa7908163981f4a03da9adff28c0a6c0851626fd852846c211
+  metadata.gz: b2ce1f4f619d3bd9eb680ad49ad0181ef4a5e81b0a9fa07f0b8e544b85b77028
+  data.tar.gz: 34de290127df74e156b02e595f2b1ea91ab3da6edf38cfff263a4734e16297cc
 SHA512:
-  metadata.gz: e0252b16b333e1218f0869a876f4687cb0513b0efe82af6fcc7ceedc140fa97dd5a30d7a22ca32d3d9894ce20669b6a34fb17fc56661e1d6676b421f7ca24a97
-  data.tar.gz: de69b22e572d2498ad4cc085ec821fab75043119dcaa219fe4fba48b9c2d5aac9552534274b39629d209a5aa6859e29b9562f6e193e54c9db435f97a8ad2f65a
+  metadata.gz: 2a89223df4da4f8effb784628e711bd9341b63b096ecfa5d1bb970f2d9a447c59e51871167c7da1f48eb3fc70436970fe64a84400ab93ab7e835e7d165cc203b
+  data.tar.gz: 81cd03234bc8eff7a0acc6d69105ba5cf9599b8ad9b8193c28679d6c1fb504a612cb9c5062bba7f4c3ebe5448636908c8c87e75666de0575b78bb28d9a4b0e8f

data/Gemfile

@@ -12,7 +12,8 @@ end
 
 group :development, :test do
   gem 'awesome_print'
+  gem 'certificate_authority'
   gem 'guard-rake'
   gem 'pry-byebug', platforms: [:mri]
-  gem 'reel', require: 'reel/h2', git: 'https://github.com/kenichi/reel', branch: 'h2'
+  gem 'reel', '0.6.1'
 end

data/README.md

@@ -2,14 +2,36 @@
 
 [![Build Status](https://travis-ci.org/kenichi/h2.svg?branch=master)](https://travis-ci.org/kenichi/h2)
 
-H2 is a basic, _experimental_ HTTP/2 client based on the [http-2](https://github.com/igrigorik/http-2) gem.
+H2 is an HTTP/2 client and server based on the [http-2](https://github.com/igrigorik/http-2) gem.
 
 H2 uses:
 
 * keyword arguments (>=2.0)
 * exception-less socket IO (>=2.3).
 
-## Usage
+## Server Usage
+
+Server API is currently optional, and must be required separately. The server
+uses [Reel](https://github.com/celluloid/reel), but since this API is optional,
+reel must be separately added to `Gemfile`. It is currently based on `reel-0.6.1`.
+
+```ruby
+require 'h2/server'
+
+server = H2::Server::HTTP.new host: addr, port: port do |connection|
+  connection.each_stream do |stream|
+    stream.respond :ok, "hello, world!\n"
+    stream.connection.goaway
+  end
+end
+
+stream = H2.get url: "http://#{addr}:#{port}", tls: false
+stream.body #=> "hello, world!\n"
+```
+
+See [examples](https://github.com/kenichi/h2/tree/master/examples/server/)
+
+## Client Usage
 
 ```ruby
 require 'h2'
@@ -44,10 +66,10 @@ stream.closed? #=> true
 
 client.closed? #=> false unless server sent GOAWAY
 
-stream = client.get path: '/push_promise' do |s| # H2::Stream === s
-  s.on :headers do |h|
-    if h['ETag'] == 'some_value']
-      s.cancel! # already have 
+client.on :promise do |p| # check/cancel a promise
+  p.on :headers do |h|
+    if h['etag'] == 'some_value'
+      p.cancel!  # already have 
     end
   end
 end
@@ -69,13 +91,13 @@ end
 client.goaway!
 ```
 
-## CLI
+## Client CLI
 
 For more info on using the CLI `h2` installed with this gem:
 
 `$ h2 --help`
 
-## TLS CA Certificates
+## Using TLS CA Certificates with the Client
 
 If you're running on macOS and using Homebrew's openssl package, you may need to
 specify the CA file in the TLS options:
@@ -101,7 +123,7 @@ Neither of these gems are hard dependencies. If you want to use either one, you
 have it available to your Ruby VM, most likely via Bundler, *and* require the
 sub-component of h2 that will prepend and extend `H2::Client`. They are also intended
 to be mutually exclusive: you can have both in your VM, but you can only use one at a
-time with h2.
+time with h2's client.
 
 #### Celluloid Pool
 
@@ -113,6 +135,10 @@ require 'h2/client/celluloid'
 
 This will lazily fire up a celluloid pool, with defaults defined by Celluloid.
 
+NOTE: if you've added reel and required the 'h2/server' API, Celluloid will be
+loaded in your Ruby VM already; however, you must still require this to have
+the client use Celluloid actor pools.
+
 #### Concurrent-Ruby ThreadPoolExecutor
 
 To use a concurrent-ruby thread pool executor for reading from `H2::Client` connections:
@@ -137,6 +163,7 @@ max_queue:   procs * 5
 * [x] push promise cancellation
 * [x] alternate concurrency models
 * [ ] fix up CLI to be more curlish
+* [ ] update server API
 
 ## Contributing
 

data/bin/console

@@ -3,6 +3,7 @@
 require 'bundler/setup'
 require 'h2'
 require 'irb'
+require 'celluloid/current'
 
 Bundler.require :development
 IRB.start

data/examples/server/hello_world.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/server/hello_world.rb
+
+require 'bundler/setup'
+require 'h2/server'
+
+H2::Logger.level = ::Logger::DEBUG
+H2.verbose!
+
+addr, port = '127.0.0.1', 1234
+
+puts "*** Starting server on http://#{addr}:#{port}"
+s = H2::Server::HTTP.new host: addr, port: port do |connection|
+  connection.each_stream do |stream|
+    stream.respond :ok, "hello, world!\n"
+    stream.connection.goaway
+  end
+end
+
+sleep

data/examples/server/https_hello_world.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/server/https_hello_world.rb
+
+require 'bundler/setup'
+require 'h2/server'
+
+port       = 1234
+addr       = Socket.getaddrinfo('localhost', port).first[3]
+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}"
+
+s = H2::Server::HTTPS.new host: addr, port: port, **tls do |connection|
+  connection.each_stream do |stream|
+    stream.goaway_on_complete
+
+    if stream.request.path == '/favicon.ico'
+      stream.respond :not_found
+    else
+      stream.respond :ok, "hello, world!\n"
+    end
+  end
+end
+
+sleep

data/examples/server/push_promise.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/server/push_promise.rb
+
+require 'bundler/setup'
+require 'h2/server'
+
+H2::Logger.level = ::Logger::DEBUG
+H2.verbose!
+
+port         = 1234
+addr         = 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>wait for it...<img src="/dog.png"/><script src="/pushed.js"></script></html>'
+pushed_js    = '(()=>{ alert("hello h2 push promise!"); })();'
+
+sni = {
+  'localhost' => {
+    :cert => certs_dir + '/server.crt',
+    :key  => certs_dir + '/server.key',
+    # :extra_chain_cert => certs_dir + '/chain.pem'
+  }
+}
+
+puts "*** Starting server on https://#{addr}:#{port}"
+s = H2::Server::HTTPS.new host: addr, port: port, sni: sni do |connection|
+  connection.each_stream do |stream|
+
+    if stream.request.path == '/favicon.ico'
+      stream.respond :not_found
+
+    else
+      stream.goaway_on_complete
+
+      stream.push_promise '/dog.png', { 'content-type' => 'image/png' }, dog_png
+
+      js_promise = stream.push_promise_for '/pushed.js', { 'content-type' => 'application/javascript' }, pushed_js
+      js_promise.make_on stream
+
+      stream.respond :ok, push_promise
+
+      js_promise.keep
+    end
+  end
+end
+
+sleep

data/h2.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |spec|
   spec.version       = H2::VERSION
   spec.authors       = ["Kenichi Nakamura"]
   spec.email         = ["kenichi.nakamura@gmail.com"]
-  spec.summary       = 'an http/2 client based on http-2'
-  spec.description   = 'a pure ruby http/2 client based on http-2'
+  spec.summary       = 'an http/2 client & server based on http-2'
+  spec.description   = 'a pure ruby http/2 client & server based on http-2'
   spec.homepage      = 'https://github.com/kenichi/h2'
   spec.license       = 'MIT'
   spec.bindir        = 'exe'
@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.2'
 
-  spec.add_dependency 'http-2', '~> 0.8', '>= 0.8.4'
+  spec.add_dependency 'http-2', '~> 0.9', '>= 0.9.1'
   spec.add_dependency 'colored', '1.2'
 
   spec.add_development_dependency "bundler", "~> 1.15"

data/lib/h2/reel/ext.rb

@@ -0,0 +1,48 @@
+require 'reel/connection'
+require 'reel/request'
+require 'reel/server'
+
+# see also: https://github.com/celluloid/reel/pull/228
+
+
+# this is a little sneaky, not as direct as the PR above, but the least
+# invasive way i could come up with to get access to the server from the
+# request.
+
+module Reel
+
+  # we add a `server` accessor to +Connection+...
+  #
+  class Request
+    attr_reader :connection
+  end
+
+  # ... and a `connection` reader to +Request+.
+  #
+  class Connection
+    attr_accessor :server
+  end
+
+end
+
+module H2
+  module Reel
+    module ServerConnection
+
+      # then we hijack +Server+ construction, and wrap the callback at the last
+      # minute with one that sets the server on every connection, before
+      # calling the original.
+      #
+      def initialize server, options = {}, &callback
+        super
+        @og_callback = @callback
+        @callback = ->(conn) {
+          conn.server = self
+          @og_callback[conn]
+        }
+      end
+    end
+
+    ::Reel::Server.prepend ServerConnection
+  end
+end

data/lib/h2/server/connection.rb

@@ -0,0 +1,153 @@
+require 'h2/server/stream'
+
+module H2
+  class Server
+
+    # handles reading data from the +@socket+ into the +HTTP2::Server+ +@parser+,
+    # callbacks from the +@parser+, and closing of the +@socket+
+    #
+    class Connection
+
+      # each +@parser+ event method is wrapped in a block to call a local instance
+      # method of the same name
+      #
+      PARSER_EVENTS = [
+        :frame,
+        :frame_sent,
+        :frame_received,
+        :stream,
+        :goaway
+      ]
+
+      attr_reader :parser, :server, :socket
+
+      def initialize socket:, server:
+        @socket   = socket
+        @server   = server
+        @parser   = ::HTTP2::Server.new
+        @attached = true
+
+        yield self if block_given?
+
+        bind_events
+
+        Logger.debug "new H2::Connection: #{self}" if H2.verbose?
+      end
+
+      # is this connection still attached to the server reactor?
+      #
+      def attached?
+        @attached
+      end
+
+      # bind parser events to this instance
+      #
+      def bind_events
+        PARSER_EVENTS.each do |e|
+          on = "on_#{e}".to_sym
+          @parser.on(e) { |x| __send__ on, x }
+        end
+      end
+
+      # closes this connection's socket if attached
+      #
+      def close
+        socket.close if socket && attached?
+      end
+
+      # is this connection's socket closed?
+      #
+      def closed?
+        socket.closed?
+      end
+
+      # prevent this server reactor from handling this connection
+      #
+      def detach
+        @attached = false
+        self
+      end
+
+      # accessor for stream handler
+      #
+      def each_stream &block
+        @each_stream = block if block_given?
+        @each_stream
+      end
+
+      # queue a goaway frame
+      #
+      def goaway
+        server.async.goaway self
+      end
+
+      # begins the read loop, handling all errors with a log message,
+      # backtrace, and closing the +@socket+
+      #
+      def read
+        begin
+          while attached? && !@socket.closed? && !(@socket.eof? rescue true)
+            data = @socket.readpartial(4096)
+            @parser << data
+          end
+          close
+
+        rescue => e
+          Logger.error "Exception: #{e.message} - closing socket"
+          STDERR.puts e.backtrace
+          close
+
+        end
+      end
+
+      protected
+
+      # +@parser+ event methods
+
+      # called by +@parser+ with a binary frame to write to the +@socket+
+      #
+      def on_frame bytes
+        Logger.debug "Writing bytes: #{truncate_string(bytes.unpack("H*").first)}" if H2.verbose?
+
+        # N.B. this is the important bit
+        #
+        @socket.write bytes
+      rescue IOError, Errno::EPIPE => e
+        Logger.error e.message
+        close
+      end
+
+      def on_frame_sent f
+        Logger.debug "Sent frame: #{truncate_frame(f).inspect}" if H2.verbose?
+      end
+
+      def on_frame_received f
+        Logger.debug "Received frame: #{truncate_frame(f).inspect}" if H2.verbose?
+      end
+
+      # the +@parser+ calls this when a new stream has been initiated by the
+      # client
+      #
+      def on_stream stream
+        H2::Server::Stream.new connection: self, stream: stream
+      end
+
+      # the +@parser+ calls this when a goaway frame is received from the client
+      #
+      def on_goaway event
+        close
+      end
+
+      private
+
+      def truncate_string s
+        (String === s && s.length > 64) ? "#{s[0,64]}..." : s
+      end
+
+      def truncate_frame f
+        f.reduce({}) { |h, (k, v)| h[k] = truncate_string(v); h }
+      end
+
+    end
+  end
+end

data/lib/h2/server/https.rb

@@ -0,0 +1,171 @@
+module H2
+  class Server
+
+    # 'h2' server - for TLS 1.2 ALPN HTTP/2 connection
+    #
+    # @see https://tools.ietf.org/html/rfc7540#section-3.3
+    #
+    class HTTPS < H2::Server
+
+      ALPN_PROTOCOL        = 'h2'
+      ALPN_SELECT_CALLBACK = ->(ps){ ps.find { |p| ALPN_PROTOCOL == p }}
+      ECDH_CURVES          = 'P-256'
+      TMP_ECDH_CALLBACK    = ->(*_){ OpenSSL::PKey::EC.new 'prime256v1' }
+
+      ECDH_OPENSSL_MIN_VERSION = '2.0'
+
+      # create a new h2 server that uses SNI to determine TLS cert/key to use
+      #
+      # @see https://en.wikipedia.org/wiki/Server_Name_Indication
+      #
+      # @param [String] host the IP address for this server to listen on
+      # @param [Integer] port the TCP port for this server to listen on
+      # @param [Hash] sni the SNI option hash with certs/keys for domains
+      # @param [Hash] options
+      #
+      # @option [String] :cert TLS certificate
+      # @option [String] :extra_chain_cert TLS certificate
+      # @option [String] :key TLS key
+      #
+      # == SNI options with default callback
+      #
+      # [:sni] Hash with domain name +String+ keys and +Hash+ values:
+      #     [:cert] +String+ TLS certificate
+      #     [:extra_chain_cert] +String+ TLS certificate
+      #     [:key] +String+ TLS key
+      #
+      # == SNI options with _custom_ callback
+      #
+      # [:sni] Hash:
+      #     [:callback] +Proc+ creates +OpenSSL::SSL::SSLContext+ for each
+      #                        connection
+      #
+      def initialize host:, port:, sni: {}, **options, &on_connection
+        @sni          = sni
+        @sni_callback = @sni[:callback] || method(:sni_callback)
+        @tcpserver    = Celluloid::IO::TCPServer.new host, port
+        @sslserver    = Celluloid::IO::SSLServer.new @tcpserver, create_ssl_context(options)
+        options.merge! host: host, port: port, sni: sni
+        super @sslserver, options, &on_connection
+      end
+
+      # accept a socket connection, possibly attach spy, hand off to +#handle_connection+
+      # asyncronously, repeat
+      #
+      def run
+        loop do
+          begin
+            socket = @server.accept
+          rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET, Errno::EPIPE,
+                 Errno::ETIMEDOUT, Errno::EHOSTUNREACH => ex
+            Logger.warn "Error accepting SSLSocket: #{ex.class}: #{ex.to_s}"
+            retry
+          end
+
+          socket = ::Reel::Spy.new(socket, @spy) if @spy
+          async.handle_connection socket
+        end
+      end
+
+      private
+
+      # default SNI callback - builds SSLContext from cert/key by domain name in +@sni+
+      # or returns existing one if name is not found
+      #
+      def sni_callback args
+        socket, name = args
+        @contexts ||= {}
+        if @contexts[name]
+          @contexts[name]
+        elsif sni_opts = @sni[name] and Hash === sni_opts
+          @contexts[name] = create_ssl_context sni_opts
+        else
+          socket.context
+        end
+      end
+
+      # builds a new SSLContext suitable for use in 'h2' connections
+      #
+      def create_ssl_context **opts
+        ctx                  = OpenSSL::SSL::SSLContext.new
+        ctx.ca_file          = opts[:ca_file] if opts[:ca_file]
+        ctx.ca_path          = opts[:ca_path] if opts[:ca_path]
+        ctx.cert             = context_cert opts[:cert]
+        ctx.ciphers          = opts[:ciphers] || OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
+        ctx.extra_chain_cert = context_extra_chain_cert opts[:extra_chain_cert]
+        ctx.key              = context_key opts[:key]
+        ctx.options          = opts[:options] || OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
+        ctx.servername_cb    = @sni_callback
+        ctx.ssl_version      = :TLSv1_2
+        context_ecdh ctx
+
+        # https://github.com/jruby/jruby-openssl/issues/99
+        context_set_protocols ctx unless H2.jruby?
+
+        ctx
+      end
+
+      private
+
+      if OpenSSL::VERSION >= ECDH_OPENSSL_MIN_VERSION && RUBY_VERSION >= '2.3'
+        def context_ecdh ctx
+          ctx.ecdh_curves = ECDH_CURVES
+        end
+      else
+        if H2.jruby? || RUBY_VERSION < '2.3'
+          def context_ecdh ctx
+          end
+        else
+          def context_ecdh ctx
+            ctx.tmp_ecdh_callback = TMP_ECDH_CALLBACK
+          end
+        end
+      end
+
+      def context_cert cert
+        case cert
+        when String
+          cert = File.read cert if File.exist? cert
+          OpenSSL::X509::Certificate.new cert
+        when OpenSSL::X509::Certificate
+          cert
+        end
+      end
+
+      def context_key key
+        case key
+        when String
+          key = File.read key if File.exist? key
+          OpenSSL::PKey::RSA.new key
+        when OpenSSL::PKey::RSA
+          key
+        end
+      end
+
+      def context_extra_chain_cert chain
+        case chain
+        when String
+          chain = File.read chain if File.exist? chain
+          [OpenSSL::X509::Certificate.new(chain)]
+        when OpenSSL::X509::Certificate
+          [chain]
+        when Array
+          chain
+        end
+      end
+
+      if H2.alpn?
+        def context_set_protocols ctx
+          ctx.alpn_protocols = [ALPN_PROTOCOL]
+          ctx.alpn_select_cb = ALPN_SELECT_CALLBACK
+        end
+      else
+        def context_set_protocols ctx
+          ctx.npn_protocols = [ALPN_PROTOCOL]
+          ctx.npn_select_cb = ALPN_SELECT_CALLBACK
+        end
+      end
+
+    end
+  end
+end

data/lib/h2/server/push_promise.rb

@@ -0,0 +1,125 @@
+module H2
+  class Server
+    class PushPromise
+
+      GET    = 'GET'
+      STATUS = '200'
+
+      attr_reader :content_length, :path, :push_stream
+
+      # build a new +PushPromise+ for the path, with the headers and body given
+      #
+      def initialize path, body_or_headers = {}, body = nil
+        @path = path
+        if Hash === body_or_headers
+          headers = body_or_headers.dup
+          @body = body
+        else
+          headers = {}
+          @body = body_or_headers
+        end
+
+        @promise_headers = {
+          METHOD_KEY    => GET,
+          AUTHORITY_KEY => headers.delete(AUTHORITY_KEY),
+          PATH_KEY      => @path,
+          SCHEME_KEY    => headers.delete(SCHEME_KEY)
+        }
+
+        @content_length = @body.bytesize.to_s
+
+        @push_headers = {
+          STATUS_KEY         => STATUS,
+          CONTENT_LENGTH_KEY => @content_length
+        }.merge headers
+
+        @fsm = FSM.new
+      end
+
+      # create a new promise stream from +stream+, send the headers and set
+      # +@push_stream+ from the callback
+      #
+      def make_on stream
+        return unless @fsm.state == :init
+        @stream = stream
+        @stream.stream.promise(@promise_headers, end_headers: false) do |push|
+          push.headers @push_headers
+          @push_stream = push
+          @push_stream.on(:close){|err| cancel! if err == :cancel}
+        end
+        @fsm.transition :made
+        self
+      end
+
+      def keep_async
+        @stream.connection.server.async.handle_push_promise self
+      end
+
+      # deliver the body for this promise, optionally splicing into +size+ chunks
+      #
+      def keep size = nil
+        return false unless @fsm.state == :made
+
+        if size.nil?
+          @push_stream.data @body
+        else
+          body = @body
+
+          if body.bytesize > size
+            body = @body.dup
+            while body.bytesize > size
+              @push_stream.data body.slice!(0, size), end_stream: false
+              yield if block_given?
+            end
+          else
+            yield if block_given?
+          end
+
+          @push_stream.data body
+        end
+
+        @fsm.transition :kept
+        log :info, self
+        @stream.on_complete
+      end
+
+      def kept?
+        @fsm.state == :kept
+      end
+
+      def canceled?
+        @fsm.state == :canceled
+      end
+
+      # cancel this promise, most likely due to a RST_STREAM frame from the
+      # client (already in cache, etc...)
+      #
+      def cancel!
+        @fsm.transition :canceled
+        @stream.on_complete
+      end
+
+      def log level, msg
+        Logger.__send__ level, "[stream #{@push_stream.id}] #{msg}"
+      end
+
+      def to_s
+        request = @stream.request
+        %{#{request.addr} "push #{@path} HTTP/2" #{STATUS} #{@content_length}}
+      end
+      alias to_str to_s
+
+      # simple state machine to guarantee promise process
+      #
+      class FSM
+        include Celluloid::FSM
+        default_state :init
+        state :init, to: [:canceled, :made]
+        state :made, to: [:canceled, :kept]
+        state :kept
+        state :canceled
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module H2
+  class Server
+    class Stream
+      class Request
+
+        # a case-insensitive hash that also handles symbol translation i.e. s/_/-/
+        #
+        HEADER_HASH = Hash.new do |hash, key|
+          k = key.to_s.upcase
+          k.gsub! '_', '-' if Symbol === key
+          _, value = hash.find {|header_key,v| header_key.upcase == k}
+          hash[key] = value if value
+        end
+
+        attr_reader :body, :headers, :stream
+
+        def initialize stream
+          @stream  = stream
+          @headers = HEADER_HASH.dup
+          @body    = ''
+        end
+
+        # retreive the IP address of the connection
+        #
+        def addr
+          @addr ||= @stream.connection.socket.peeraddr[3] rescue nil
+        end
+
+        # retreive the authority from the stream request headers
+        #
+        def authority
+          @authority ||= headers[AUTHORITY_KEY]
+        end
+
+        # retreive the HTTP method as a lowercase +Symbol+
+        #
+        def method
+          return @method unless @method.nil?
+          @method = headers[METHOD_KEY]
+          @method = @method.downcase.to_sym if @method
+          @method
+        end
+
+        # retreive the path from the stream request headers
+        #
+        def path
+          @path ||= headers[PATH_KEY]
+        end
+
+        # retreive the scheme from the stream request headers
+        #
+        def scheme
+          @scheme ||= headers[SCHEME_KEY]
+        end
+
+        # respond to this request on its stream
+        #
+        def respond response, body_or_headers = nil, body = nil
+          @stream.respond response, body_or_headers, body
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module H2
+  class Server
+    class Stream
+      class Response
+
+        attr_reader :body, :content_length, :headers, :status, :stream
+
+        # build a new +Response+ object
+        #
+        def initialize stream:, status:, headers: {}, body: ''
+          @stream     = stream
+          @headers    = headers
+          @body       = body
+          self.status = status
+
+          init_content_length
+        end
+
+        # sets the content length in the headers by the byte size of +@body+
+        #
+        def init_content_length
+          @content_length = case @body
+                            when String
+                              @body.bytesize
+                            when IO
+                              @body.stat.size
+                            when NilClass
+                              '0'
+                            else
+                              raise TypeError, "can't render #{@body.class} as a response body"
+                            end
+
+          unless @headers.any? {|k,_| k.downcase == CONTENT_LENGTH_KEY}
+            @headers[CONTENT_LENGTH_KEY] = @content_length
+          end
+        end
+
+        # the corresponding +Request+ to this +Response+
+        #
+        def request
+          stream.request
+        end
+
+        # send the headers and body out on +s+, an +HTTP2::Stream+ object
+        #
+        # NOTE: +:status+ must come first?
+        #
+        def respond_on s
+          headers = { STATUS_KEY => @status.to_s }.merge @headers
+          s.headers stringify_headers(headers)
+          case @body
+          when String
+            s.data @body
+          when IO
+            raise NotImplementedError # TODO
+          else
+          end
+        end
+
+        # sets +@status+ either from given integer value (HTTP status code) or by
+        # mapping a +Symbol+ in +Reel::Response::SYMBOL_TO_STATUS_CODE+ to one
+        #
+        def status= status
+          case status
+          when Integer
+            @status = status
+          when Symbol
+            if code = ::Reel::Response::SYMBOL_TO_STATUS_CODE[status]
+              self.status = code
+            else
+              raise ArgumentError, "unrecognized status symbol: #{status}"
+            end
+          else
+            raise TypeError, "invalid status type: #{status.inspect}"
+          end
+        end
+
+        def to_s
+          %{#{request.addr} "#{request.method} #{request.path} HTTP/2" #{status} #{content_length}}
+        end
+        alias to_str to_s
+
+        private
+
+        def stringify_headers hash
+          hash.keys.each do |k|
+            hash[k] = hash[k].to_s unless String === hash[k]
+            if Symbol === k
+              key = k.to_s.gsub '_', '-'
+              hash[key] = hash.delete k
+            end
+          end
+          hash
+        end
+
+      end
+    end
+  end
+end

data/lib/h2/server/stream.rb

@@ -0,0 +1,208 @@
+require 'h2/server/stream/request'
+require 'h2/server/stream/response'
+require 'h2/server/push_promise'
+
+module H2
+  class Server
+    class Stream
+
+      # each stream event method is wrapped in a block to call a local instance
+      # method of the same name
+      #
+      STREAM_EVENTS = [
+        :active,
+        :close,
+        :half_close
+      ]
+
+      # the above take only the event, the following receive both the event
+      # and the data
+      #
+      STREAM_DATA_EVENTS = [
+        :headers,
+        :data
+      ]
+
+      attr_reader :connection,
+                  :push_promises,
+                  :request,
+                  :response,
+                  :stream
+
+      def initialize connection:, stream:
+        @closed        = false
+        @completed     = false
+        @connection    = connection
+        @push_promises = Set.new
+        @responded     = false
+        @stream        = stream
+
+        bind_events
+      end
+
+      # mimicing Reel::Connection#respond
+      #
+      # write status, headers, and data to +@stream+
+      #
+      def respond response, body_or_headers = nil, body = nil
+
+        # :/
+        #
+        if Hash === body_or_headers
+          headers = body_or_headers
+          body ||= ''
+        else
+          headers = {}
+          body = body_or_headers ||= ''
+        end
+
+        @response = case response
+                    when Symbol, Integer
+                      response = Response.new stream: self,
+                                              status: response,
+                                              headers: headers,
+                                              body: body
+                    when Response
+                      response
+                    else raise TypeError, "invalid response: #{response.inspect}"
+                    end
+
+        if @closed
+          log :warn, 'stream closed before response sent'
+        else
+          response.respond_on(stream)
+          log :info, response
+          @responded = true
+        end
+      end
+
+      # create a push promise, send the headers, then queue an asynchronous
+      # task on the reactor to deliver the data
+      #
+      def push_promise *args
+        pp = push_promise_for *args
+        make_promise pp
+        @connection.server.async.handle_push_promise pp
+      end
+
+      # create a push promise - mimicing Reel::Connection#respond
+      #
+      def push_promise_for path, body_or_headers = {}, body = nil
+
+        # :/
+        #
+        case body_or_headers
+        when Hash
+          headers = body_or_headers
+        else
+          headers = {}
+          body = body_or_headers
+        end
+
+        headers.merge! AUTHORITY_KEY => @request.authority,
+                       SCHEME_KEY    => @request.scheme
+
+        PushPromise.new path, headers, body
+      end
+
+      # begin the new push promise stream from this +@stream+ by sending the
+      # initial headers frame
+      #
+      # @see +PushPromise#make_on!+
+      # @see +HTTP2::Stream#promise+
+      #
+      def make_promise p
+        p.make_on self
+        push_promises << p
+        p
+      end
+
+      # set or call +@complete+ callback
+      #
+      def on_complete &block
+        return true if @completed
+        if block
+          @complete = block
+        elsif @completed = (@responded and push_promises_complete?)
+          @complete[] if Proc === @complete
+          true
+        else
+          false
+        end
+      end
+
+      # check for push promises completion
+      #
+      def push_promises_complete?
+        @push_promises.empty? or @push_promises.all? {|p| p.kept? or p.canceled?}
+      end
+
+      # trigger a GOAWAY frame when this stream is responded to and any/all push
+      # promises are complete
+      #
+      def goaway_on_complete
+        on_complete { connection.goaway }
+      end
+
+      # logging helper
+      #
+      def log level, msg
+        Logger.__send__ level, "[stream #{@stream.id}] #{msg}"
+      end
+
+      protected
+
+      # bind parser events to this instance
+      #
+      def bind_events
+        STREAM_EVENTS.each do |e|
+          on = "on_#{e}".to_sym
+          @stream.on(e) { __send__ on }
+        end
+        STREAM_DATA_EVENTS.each do |e|
+          on = "on_#{e}".to_sym
+          @stream.on(e) { |x| __send__ on, x }
+        end
+      end
+
+      # called by +@stream+ when this stream is activated
+      #
+      def on_active
+        log :debug, 'active' if H2.verbose?
+        @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?
+        on_complete
+        @closed = true
+      end
+
+      # called by +@stream+ with a +Hash+
+      #
+      def on_headers h
+        incoming_headers = Hash[h]
+        log :debug, "headers: #{incoming_headers}" if H2.verbose?
+        @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?
+        @request.body << d
+      end
+
+      # called by +@stream+ when body/request is complete, signaling that client
+      # is ready for response(s)
+      #
+      def on_half_close
+        log :debug, 'half_close' if H2.verbose?
+        connection.server.async.handle_stream self
+      end
+
+    end
+  end
+end

data/lib/h2/server.rb

@@ -0,0 +1,98 @@
+require 'celluloid/current'
+require 'logger'
+require 'reel'
+require 'h2/reel/ext'
+require 'h2'
+
+module H2
+
+  CONTENT_LENGTH_KEY = 'content-length'
+
+  Logger = ::Logger.new STDOUT
+
+  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
+
+    # turn on extra verbose debug logging
+    #
+    def verbose!
+      @verbose = true
+    end
+
+    def verbose?
+      @verbose = false unless defined?(@verbose)
+      @verbose
+    end
+
+  end
+
+  # base H2 server, a direct subclass of +Reel::Server+
+  #
+  class Server < ::Reel::Server
+
+    def initialize server, **options, &on_connection
+      @on_connection = on_connection
+      super server, options
+    end
+
+    # build a new connection object, run it through the given block, and
+    # start reading from the socket if still attached
+    #
+    def handle_connection socket
+      connection = H2::Server::Connection.new socket: socket, server: self
+      @on_connection[connection]
+      connection.read if connection.attached?
+    end
+
+    # async stream handling
+    #
+    def handle_stream stream
+      stream.connection.each_stream[stream]
+    end
+
+    # async push promise
+    #
+    def handle_push_promise push_promise
+      push_promise.keep
+    end
+
+    # async goaway
+    #
+    def goaway connection
+      sleep 0.25
+      connection.parser.goaway unless connection.closed?
+    end
+
+    # 'h2c' server - for plaintext HTTP/2 connection
+    #
+    # NOTE: browsers don't support this and probably never will
+    #
+    # @see https://tools.ietf.org/html/rfc7540#section-3.4
+    # @see https://hpbn.co/http2/#upgrading-to-http2
+    #
+    class HTTP < H2::Server
+
+      # create a new h2c server
+      #
+      def initialize host:, port:, **options, &on_connection
+        @tcpserver = Celluloid::IO::TCPServer.new host, port
+        options.merge! host: host, port: port
+        super @tcpserver, options, &on_connection
+      end
+
+    end
+
+  end
+
+end
+
+require 'h2/server/connection'
+require 'h2/server/https'

data/lib/h2/version.rb

@@ -1,5 +1,5 @@
 module H2
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 
   class << self
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h2
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Kenichi Nakamura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-17 00:00:00.000000000 Z
+date: 2018-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
+        version: 0.9.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: colored
   requirement: !ruby/object:Gem::Requirement
@@ -86,7 +86,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: a pure ruby http/2 client based on http-2
+description: a pure ruby http/2 client & server based on http-2
 email:
 - kenichi.nakamura@gmail.com
 executables:
@@ -104,6 +104,10 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- examples/server/dog.png
+- examples/server/hello_world.rb
+- examples/server/https_hello_world.rb
+- examples/server/push_promise.rb
 - exe/h2
 - h2.gemspec
 - lib/h2.rb
@@ -111,6 +115,14 @@ files:
 - lib/h2/client/celluloid.rb
 - lib/h2/client/concurrent.rb
 - lib/h2/client/tcp_socket.rb
+- lib/h2/reel/ext.rb
+- lib/h2/server.rb
+- lib/h2/server/connection.rb
+- lib/h2/server/https.rb
+- lib/h2/server/push_promise.rb
+- lib/h2/server/stream.rb
+- lib/h2/server/stream/request.rb
+- lib/h2/server/stream/response.rb
 - lib/h2/stream.rb
 - lib/h2/version.rb
 homepage: https://github.com/kenichi/h2
@@ -136,5 +148,5 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: an http/2 client based on http-2
+summary: an http/2 client & server based on http-2
 test_files: []