h2 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a9868c3d9496207683352704cd152a9d5426ff42cd3aa30035a56981596e957
-  data.tar.gz: 43e60980d431d769835d4bb15de0cacbb5676c250b1e461c31e4f88c89734c48
+  metadata.gz: a59b70f55abe247ca3ae333b72031a32f880fa1844bd8058585a4090bcc55969
+  data.tar.gz: d28023b7123b0819c1f540070831188fd99460f11fe9914c2d8c00c7e4dd4e6d
 SHA512:
-  metadata.gz: 19e4e75141869144f1ed7b6abf8b6faeb61d00db6466d02ec5264ec7d95ddada0de2914b071dc13a5293885189fea5cb9b235515fc8e282218244d19b5eea08a
-  data.tar.gz: 50a36bbc351d0dca3cc81750800e2a5085e403bc6019a8620cef8ec5d8977c4e227dcd994656365eb9d75ae03d4fdb0dd9d2e740f2eeccbdf636210f8952dd50
+  metadata.gz: a7e502860f2f753ed37f419ba41b78c9399fe8a6278cbfe937ccd7c04f8da0c7fd53fdbc960454ac389a3b4a4073d3a39737a643fdf09235aac281b7f15f67eb
+  data.tar.gz: 2dfa20d7aafdc0e37cd61aba4c6a2d9696c4efb58de3786f87c628f08c65bb5437baebdc93dd2acd4f27abde49021f2ac82d58d06ea9d133359d6d9098c8c6b4

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 h2 changelog
 ============
 
+### 0.7.0 2 aug 2018
+
+* `Server::Stream::Request#path` now removes query string
+* add `H2::Server::Stream::Request#query_string`
+* `H2::Server::Stream::Response` body now accepts any object that `respond_to? :each`
+* remove Reel completely, base from Celluloid::IO
+* add SSE support
+
 ### 0.6.1 27 jul 2018
 
 * fix race between reading and sending first frame

data/Gemfile

@@ -2,14 +2,12 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'http-2', path: '../http-2'
-
 group :concurrent_ruby do
   gem 'concurrent-ruby'
 end
 
 group :celluloid do
-  gem 'celluloid'
+  gem 'celluloid', '~> 0.17', '>= 0.17.3'
 end
 
 group :development, :test do
@@ -17,5 +15,5 @@ group :development, :test do
   gem 'certificate_authority'
   gem 'guard-rake'
   gem 'pry-byebug', platforms: [:mri]
-  gem 'reel', '0.6.1'
+  gem 'celluloid-io', '~> 0.17', '>= 0.17.3'
 end

data/README.md

@@ -12,8 +12,8 @@ H2 uses:
 ## 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`.
+uses [Celluloid::IO](https://github.com/celluloid/celluloid-io), but since this API is optional,
+celluloid-io must be separately added to `Gemfile`. It is currently based on `celluloid-io-0.17.3`.
 
 ```ruby
 require 'h2/server'
@@ -135,9 +135,9 @@ 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.
+NOTE: if you've added celluloid-io 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
 

data/Rakefile

@@ -3,7 +3,7 @@ require "rake/testtask"
 
 task default: :test
 
-Rake::TestTask.new :test do |t|
+Rake::TestTask.new :test => ['test:certs'] do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
@@ -18,4 +18,19 @@ 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 => [:certs] do
+    system "docker build -t h2_nginx_http2 test/support/nginx"
+    puts "\nstarting nginx with http/2 support"
+    puts "using document root: test/support/nginx/"
+    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"
+  end
+
 end

data/examples/server/push_promise.rb

@@ -7,8 +7,8 @@ require 'h2/server'
 H2::Logger.level = ::Logger::DEBUG
 H2.verbose!
 
-port         = 1234
-addr         = Socket.getaddrinfo('localhost', port).first[3]
+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>'
@@ -19,6 +19,11 @@ sni = {
     :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'
   }
 }
 

data/examples/server/sse.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/server/sse/sse.rb
+
+require 'bundler/setup'
+require 'h2/server'
+
+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
+
+sni = {
+  'localhost' => {
+    :cert => certs_dir + '/server.crt',
+    :key  => certs_dir + '/server.key',
+    # :extra_chain_cert => certs_dir + '/chain.pem'
+  }
+}
+
+event_sources = []
+
+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|
+    case stream.request.path
+    when '/favicon.ico'
+      stream.respond status: 404
+
+    when '/events'
+      es = stream.to_eventsource
+      event_sources << es
+
+    when '/msg'
+      if stream.request.method == :post
+        msg = stream.request.body
+        event_sources.each {|es| es.event name: 'msg', data: msg}
+        stream.respond status: 201
+      else
+        stream.respond status: 404
+      end
+
+    when '/sse.js'
+      stream.respond status: 404,
+                     body: "should have been pushed..."
+
+    else
+      stream.push_promise path: '/sse.js',
+                          headers: { 'content-type' => 'application/javascript' },
+                          body: data[:javascript]
+
+      stream.respond status: 200, body: data[:html]
+    end
+  end
+end
+
+DATA.each_line do |l|
+  if l.start_with?('@@')
+    key = l.strip[2..-1].to_sym
+  else
+    data[key] << l
+  end
+end
+
+sleep
+
+__END__
+@@html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>SSE example</title>
+  <script src="/sse.js"></script>
+</head>
+<body>
+  <form id="say">
+    say: <input type="text" id="words"/>
+  </form>
+  <br/>
+  <div><ol id="list"></ol></div>
+</body>
+</html>
+
+@@javascript
+document.addEventListener('DOMContentLoaded', () => {
+  let sse = new EventSource('/events');
+  sse.addEventListener('msg', (msg) => {
+    let item = document.createElement('li');
+    item.innerHTML = msg.data;
+    document.getElementById('list').appendChild(item);
+  });
+
+  let w = document.getElementById('words');
+  document.getElementById('say').onsubmit = (e) => {
+    e.preventDefault();
+    fetch('/msg', {method: 'post', body: w.value})
+      .then(() => { w.value = ''; });
+  };
+  w.focus();
+});

data/exe/h2

@@ -136,8 +136,11 @@ if options[:verbose]
 end
 
 puts s.body
+c.block! if options[:block] or !s.pushes.empty?
+s.pushes.each do |p|
+  puts "push promise: #{p.headers[':path']}"
+end
 
-c.block! if options[:block]
 c.goaway if options[:goaway]
 c.close
 

data/lib/h2.rb

@@ -161,6 +161,22 @@ module H2
 
   end
 
+  module HeaderStringifier
+
+    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
 
 require 'h2/client'

data/lib/h2/server.rb

@@ -1,6 +1,5 @@
 require 'celluloid/current'
-require 'reel'
-require 'h2/reel/ext'
+require 'celluloid/io'
 require 'h2'
 
 module H2
@@ -20,13 +19,28 @@ module H2
 
   end
 
-  # base H2 server, a direct subclass of +Reel::Server+
+  # base H2 server, a +Celluoid::IO+ production
   #
-  class Server < ::Reel::Server
+  class Server
+    include Celluloid::IO
+
+    TCP_DEFAULT_BACKLOG = 100
+
+    execute_block_on_receiver :initialize
+    finalizer :shutdown
 
     def initialize server, **options, &on_connection
+      @server        = server
+      @options       = options
       @on_connection = on_connection
-      super server, options
+
+      backlog = options.fetch :backlog, TCP_DEFAULT_BACKLOG
+      @server.listen backlog
+      async.run
+    end
+
+    def shutdown
+      @server.close if @server
     end
 
     # build a new connection object, run it through the given block, and
@@ -74,6 +88,10 @@ module H2
         super @tcpserver, options, &on_connection
       end
 
+      def run
+        loop { async.handle_connection @server.accept }
+      end
+
     end
 
   end

data/lib/h2/server/connection.rb

@@ -52,7 +52,7 @@ module H2
       # closes this connection's socket if attached
       #
       def close
-        socket.close if socket && attached?
+        socket.close if socket && attached? && !closed?
       end
 
       # is this connection's socket closed?

data/lib/h2/server/https.rb

@@ -62,7 +62,6 @@ module H2
             retry
           end
 
-          socket = ::Reel::Spy.new(socket, @spy) if @spy
           async.handle_connection socket
         end
       end

data/lib/h2/server/push_promise.rb

@@ -9,15 +9,9 @@ module H2
 
       # build a new +PushPromise+ for the path, with the headers and body given
       #
-      def initialize path, body_or_headers = {}, body = nil
+      def initialize path:, headers: {}, body: nil
         @path = path
-        if Hash === body_or_headers
-          headers = body_or_headers.dup
-          @body = body
-        else
-          headers = {}
-          @body = body_or_headers
-        end
+        @body = body
 
         @promise_headers = {
           METHOD_KEY    => GET,

data/lib/h2/server/stream.rb

@@ -1,3 +1,4 @@
+require 'h2/server/stream/event_source'
 require 'h2/server/stream/request'
 require 'h2/server/stream/response'
 require 'h2/server/push_promise'
@@ -51,8 +52,8 @@ module H2
         if @closed
           log :warn, 'stream closed before response sent'
         else
-          response.respond_on(stream)
           log :info, response
+          response.respond_on(stream)
           @responded = true
         end
       end
@@ -72,7 +73,7 @@ module H2
         headers.merge! AUTHORITY_KEY => @request.authority,
                        SCHEME_KEY    => @request.scheme
 
-        PushPromise.new path, headers, body
+        PushPromise.new path: path, headers: headers, body: body
       end
 
       # begin the new push promise stream from this +@stream+ by sending the
@@ -120,6 +121,16 @@ module H2
         Logger.__send__ level, "[stream #{@stream.id}] #{msg}"
       end
 
+      # make this stream into an SSE event source
+      #
+      # raises +StreamError+ if the request's content-type is not valid
+      #
+      # @return [H2::Server::Stream::EventSource]
+      #
+      def to_eventsource headers: {}
+        EventSource.new stream: self, headers: headers
+      end
+
       protected
 
       # bind parser events to this instance
@@ -174,5 +185,7 @@ module H2
       end
 
     end
+
+    class StreamError < StandardError; end
   end
 end

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

@@ -0,0 +1,91 @@
+module H2
+  class Server
+    class Stream
+      class EventSource
+        include HeaderStringifier
+
+        DATA_TEMPL  = "data: %s\n\n"
+        EVENT_TEMPL = "event: %s\n#{DATA_TEMPL}"
+        SSE_HEADER  = {
+          STATUS_KEY    => '200',
+          :content_type => 'text/event-stream'
+        }
+
+        # build and return +EventSource+ instance, ready for pushing out data
+        # or named events. checks accept header in the request, then responds
+        # with valid headers for beginning an SSE stream
+        #
+        # @param [H2::Server::Stream] stream: the +Stream+ instance
+        # @param [Hash] headers: optional headers to add to the intial response
+        #
+        # @return [H2::Server::Stream::EventSource]
+        #
+        def initialize stream:, headers: {}
+          @closed  = false
+          @stream  = stream
+          @parser  = @stream.stream
+          @headers = headers
+
+          check_accept_header
+          init_response
+        end
+
+        # checks accept header in the request and raises a +StreamError+ if not
+        # valid for SSE
+        #
+        def check_accept_header
+          accept = @stream.request.headers['accept']
+          unless accept == SSE_HEADER[:content_type]
+            raise StreamError, "invalid header accept: #{accept}"
+          end
+        end
+
+        # responds with SSE headers on this stream
+        #
+        def init_response
+          headers = SSE_HEADER.merge @headers
+          @parser.headers stringify_headers(headers)
+        rescue ::HTTP2::Error::StreamClosed => sc
+          @stream.log :warn, "stream closed early by client"
+        end
+
+        # send out a named event with the given data
+        #
+        # this would be handled by `es.addEventListener('name', (msg)=>{})`
+        #
+        # @param [String] name: the name of the event
+        # @param [String] data: data associated with this event
+        #
+        def event name:, data:
+          e = EVENT_TEMPL % [name, data]
+          @parser.data e, end_stream: false
+        end
+
+        # send out a message with the given data
+        #
+        # this would be handled by `es.onmessage((msg)=>{})`
+        #
+        # @param [String] data associated with this event
+        #
+        def data str
+          d = DATA_TEMPL % str
+          @parser.data d, end_stream: false
+        end
+
+        # emit a final frame on this stream with +end_stream+ flag
+        #
+        def close
+          @parser.data ''
+          @closed = true
+        end
+
+        # @return [Boolean] true if this stream is closed
+        #
+        def closed?
+          @closed
+        end
+
+      end
+    end
+  end
+end

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

@@ -44,7 +44,18 @@ module H2
         # retreive the path from the stream request headers
         #
         def path
-          @path ||= headers[PATH_KEY]
+          return @path if defined?(@path)
+          @path = headers[PATH_KEY]
+          @path = @path.split('?').first if @path
+        end
+
+        # retreive the query string from the stream request headers
+        #
+        def query_string
+          return @query_string if defined?(@query_string)
+          @query_string = headers[PATH_KEY].index '?'
+          return if @query_string.nil?
+          @query_string = headers[PATH_KEY][(@query_string + 1)..-1]
         end
 
         # retreive the scheme from the stream request headers

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

@@ -2,16 +2,26 @@ module H2
   class Server
     class Stream
       class Response
+        include HeaderStringifier
 
         attr_reader :body, :content_length, :headers, :status, :stream
 
         # build a new +Response+ object
         #
+        # @param [H2::Server::Stream] stream: Stream instance associated with this response
+        # @param [Integer] status: HTTP status code
+        # @param [Hash] headers: response headers
+        # @param [String,#each] body: response body. NOTE: may be any object that
+        #                             `respond_to? :each` which both yields and returns
+        #                             String objects.
+        #
+        # @return [H2::Server::Stream::Response]
+        #
         def initialize stream:, status:, headers: {}, body: ''
-          @stream     = stream
-          @headers    = headers
-          @body       = body
-          self.status = status
+          @stream  = stream
+          @headers = headers
+          @body    = body
+          @status  = status
 
           init_content_length
         end
@@ -19,20 +29,18 @@ module H2
         # sets the content length in the headers by the byte size of +@body+
         #
         def init_content_length
-          @content_length = case @body
-                            when String
+          return if @headers.any? {|k,_| k.downcase == CONTENT_LENGTH_KEY}
+          return if @body.respond_to?(:each)
+          @content_length = case
+                            when String === @body
                               @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
+          @headers[CONTENT_LENGTH_KEY] = @content_length
         end
 
         # the corresponding +Request+ to this +Response+
@@ -41,38 +49,21 @@ module H2
           stream.request
         end
 
-        # send the headers and body out on +s+, an +HTTP2::Stream+ object
+        # send the headers and body out on +s+, an +HTTP2::Stream+ object, and
+        # close the stream when complete.
         #
         # 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
+          if String === @body
             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}"
+            stream.log :error, "unexpected @body: #{caller[0]}"
           end
+        rescue ::HTTP2::Error::StreamClosed => sc
+          stream.log :warn, "stream closed early by client"
         end
 
         def to_s
@@ -80,19 +71,6 @@ module H2
         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

data/lib/h2/version.rb

@@ -1,5 +1,5 @@
 module H2
-  VERSION = '0.6.1'
+  VERSION = '0.7.0'
 
   class << self
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h2
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Kenichi Nakamura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-27 00:00:00.000000000 Z
+date: 2018-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -108,6 +108,7 @@ files:
 - examples/server/hello_world.rb
 - examples/server/https_hello_world.rb
 - examples/server/push_promise.rb
+- examples/server/sse.rb
 - exe/h2
 - h2.gemspec
 - lib/h2.rb
@@ -115,12 +116,12 @@ 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/event_source.rb
 - lib/h2/server/stream/request.rb
 - lib/h2/server/stream/response.rb
 - lib/h2/stream.rb

data/lib/h2/reel/ext.rb

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