plum 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7edaa74a52403fc469e096512924e275a1e0b2dc
-  data.tar.gz: b0e40798462d83baff094cbb4664401afe711694
+  metadata.gz: 3671dbbd1de29adc6a254e5c95cef0a20cce6970
+  data.tar.gz: efd31623c389dbefb5d8d46de2f4f1233d72470e
 SHA512:
-  metadata.gz: 1fda3ee328f9de55f22d575cbdde788cd388fb1df15ead696cc4f86f8ce02532c458b50dc24866d3e9032345b752dccedbb6d58c5b1bfe70606c85adeeb529ff
-  data.tar.gz: fa4810540a9d8f81a4611cd91fb24d5de3d38543b2c366474388959e6006f99bce46846abe4834b8566a6e6470d4ec2ab3215c1ee3020401d76b79af6665b819
+  metadata.gz: e8dd0b9146d5261854136d69c4bcbbe471f31daeb1785b3219779c5ad8daa76bfab82763a383e308b2c17f2fe6ec127a7c8b293ab59a33c22bb7123ecd9ccaab
+  data.tar.gz: 035f11f0270f7fb7c7c95cae95993edcf4e924d6f10643928a53f5bcbee8501b13f66b537eb2875607abf2b87f9c0fd3fd16de1241c525d91742505f2b6909f8

data/examples/client/twitter.rb

@@ -17,7 +17,7 @@ rest = Plum::Client.start("api.twitter.com", 443)
 Plum::Client.start("userstream.twitter.com", 443) { |streaming|
   streaming.get("/1.1/user.json",
                 headers: { "authorization" => SimpleOAuth::Header.new(:get, "https://userstream.twitter.com/1.1/user.json", {}, credentials).to_s,
-                           "accept-encoding" => "identity;q=1" }) { |res| # plum doesn't have built-in gzip/deflate decoder
+                           "accept-encoding" => "gzip, deflate" }) { |res|
     if res.status != "200"
       puts "failed userstream"
       exit
@@ -25,6 +25,7 @@ Plum::Client.start("userstream.twitter.com", 443) { |streaming|
 
     buf = String.new
     res.on_chunk { |chunk| # when received DATA frame
+      next if chunk.empty?
       buf << chunk
       *msgs, buf = buf.split("\r\n", -1)
 

data/lib/plum/binary_string.rb

@@ -70,6 +70,20 @@ module Plum
           # I want to write `enum_for(__method__, n)`!
         end
       end
+
+      # Splits this String into chunks.
+      # @param n [Integer] max chunk bytesize
+      # @return [Array<String>] the slices
+      def chunk(n)
+        res = []
+        pos = 0
+        lim = bytesize
+        while pos < lim
+          res << byteslice(pos, n)
+          pos += n
+        end
+        res
+      end
     end
   end
 end

data/lib/plum/client/connection.rb

@@ -12,7 +12,7 @@ module Plum
 
     # Create a new stream for HTTP request.
     def open_stream
-      next_id = @max_stream_id + (@max_stream_id.even? ? 1 : 2)
+      next_id = @max_stream_ids[1] + 2
       stream(next_id)
     end
   end

data/lib/plum/connection.rb

@@ -33,7 +33,7 @@ module Plum
       @hpack_encoder = HPACK::Encoder.new(@remote_settings[:header_table_size])
       initialize_flow_control(send: @remote_settings[:initial_window_size],
                               recv: @local_settings[:initial_window_size])
-      @max_stream_id = 0
+      @max_stream_ids = [0, -1] # [even, odd]
     end
 
     # Emits :close event. Doesn't actually close socket.
@@ -61,16 +61,16 @@ module Plum
     # Returns a Stream object with the specified ID.
     # @param stream_id [Integer] the stream id
     # @return [Stream] the stream
-    def stream(stream_id)
+    def stream(stream_id, update_max_id = true)
       raise ArgumentError, "stream_id can't be 0" if stream_id == 0
 
       stream = @streams[stream_id]
       if stream
-        if stream.state == :idle && stream.id < @max_stream_id
+        if stream.state == :idle && stream_id < @max_stream_ids[stream_id % 2]
           stream.set_state(:closed_implicitly)
         end
-      elsif stream_id > @max_stream_id
-        @max_stream_id = stream_id
+      elsif stream_id > @max_stream_ids[stream_id % 2]
+        @max_stream_ids[stream_id % 2] = stream_id if update_max_id
         stream = Stream.new(self, stream_id, state: :idle)
         callback(:stream, stream)
         @streams[stream_id] = stream
@@ -92,7 +92,14 @@ module Plum
 
     def send_immediately(frame)
       callback(:send_frame, frame)
-      @writer.call(frame.assemble)
+
+      if frame.length <= @remote_settings[:max_frame_size]
+        @writer.call(frame.assemble)
+      else
+        frame.split(@remote_settings[:max_frame_size]) { |splitted|
+          @writer.call(splitted.assemble)
+        }
+      end
     end
 
     def validate_received_frame(frame)
@@ -124,7 +131,7 @@ module Plum
       if frame.stream_id == 0
         receive_control_frame(frame)
       else
-        stream(frame.stream_id).receive_frame(frame)
+        stream(frame.stream_id, frame.type == :headers).receive_frame(frame)
       end
     end
 

data/lib/plum/connection_utils.rb

@@ -20,7 +20,7 @@ module Plum
     # Sends GOAWAY frame to the peer and closes the connection.
     # @param error_type [Symbol] The error type to be contained in the GOAWAY frame.
     def goaway(error_type = :no_error)
-      last_id = @max_stream_id
+      last_id = @max_stream_ids.max
       send_immediately Frame.goaway(last_id, error_type)
     end
 

data/lib/plum/errors.rb

@@ -30,6 +30,10 @@ module Plum
     def http2_error_code
       ERROR_CODES[@http2_error_type]
     end
+
+    def to_s
+      "#{@http2_error_type.to_s.upcase}: #{super}"
+    end
   end
 
   class RemoteHTTPError < HTTPError; end
@@ -40,12 +44,11 @@ module Plum
   class LocalStreamError < LocalHTTPError; end
 
   class LegacyHTTPError < Error
-    attr_reader :headers, :data, :parser
+    attr_reader :buf
 
-    def initialize(headers, data, parser)
-      @headers = headers
-      @data = data
-      @parser = parser
+    def initialize(message, buf = nil)
+      super(message)
+      @buf = buf
     end
   end
 

data/lib/plum/frame_factory.rb

@@ -54,37 +54,45 @@ module Plum
     # Creates a DATA frame.
     # @param stream_id [Integer] The stream ID.
     # @param payload [String] Payload.
-    # @param flags [Array<Symbol>] Flags.
-    def data(stream_id, payload, *flags)
+    # @param end_stream [Boolean] add END_STREAM flag
+    def data(stream_id, payload, end_stream: false)
       payload = payload.b if payload && payload.encoding != Encoding::BINARY
-      Frame.new(type: :data, stream_id: stream_id, flags: flags, payload: payload)
+      fval = 0
+      fval += 1 if end_stream
+      Frame.new(type_value: 0, stream_id: stream_id, flags_value: fval, payload: payload)
     end
 
     # Creates a HEADERS frame.
     # @param stream_id [Integer] The stream ID.
     # @param encoded [String] Headers.
-    # @param flags [Array<Symbol>] Flags.
-    def headers(stream_id, encoded, *flags)
-      Frame.new(type: :headers, stream_id: stream_id, flags: flags, payload: encoded)
+    # @param end_stream [Boolean] add END_STREAM flag
+    # @param end_headers [Boolean] add END_HEADERS flag
+    def headers(stream_id, encoded, end_stream: false, end_headers: false)
+      fval = 0
+      fval += 1 if end_stream
+      fval += 4 if end_headers
+      Frame.new(type_value: 1, stream_id: stream_id, flags_value: fval, payload: encoded)
     end
 
     # Creates a PUSH_PROMISE frame.
     # @param stream_id [Integer] The stream ID.
     # @param new_id [Integer] The stream ID to create.
     # @param encoded [String] Request headers.
-    # @param flags [Array<Symbol>] Flags.
-    def push_promise(stream_id, new_id, encoded, *flags)
+    # @param end_headers [Boolean] add END_HEADERS flag
+    def push_promise(stream_id, new_id, encoded, end_headers: false)
       payload = String.new.push_uint32(new_id)
                           .push(encoded)
-      Frame.new(type: :push_promise, stream_id: stream_id, flags: flags, payload: payload)
+      fval = 0
+      fval += 4 if end_headers
+      Frame.new(type: :push_promise, stream_id: stream_id, flags_value: fval, payload: payload)
     end
 
     # Creates a CONTINUATION frame.
     # @param stream_id [Integer] The stream ID.
     # @param payload [String] Payload.
-    # @param flags [Array<Symbol>] Flags.
-    def continuation(stream_id, payload, *flags)
-      Frame.new(type: :continuation, stream_id: stream_id, flags: flags, payload: payload)
+    # @param end_headers [Boolean] add END_HEADERS flag
+    def continuation(stream_id, payload, end_headers: false)
+      Frame.new(type: :continuation, stream_id: stream_id, flags_value: (end_headers && 4 || 0), payload: payload)
     end
   end
 end

data/lib/plum/frame_utils.rb

@@ -3,33 +3,28 @@ using Plum::BinaryString
 
 module Plum
   module FrameUtils
-    # Splits the DATA frame into multiple frames if the payload size exceeds max size.
+    # Splits this frame into multiple frames not to exceed MAX_FRAME_SIZE.
     # @param max [Integer] The maximum size of a frame payload.
-    # @return [Array<Frame>] The splitted frames.
-    def split_data(max)
-      return [self] if self.length <= max
-      raise "Frame type must be DATA" unless self.type == :data
-
-      fragments = self.payload.each_byteslice(max).to_a
-      frames = fragments.map {|fragment| Frame.new(type: :data, flags: [], stream_id: self.stream_id, payload: fragment) }
-      frames.first.flags = self.flags - [:end_stream]
-      frames.last.flags = self.flags & [:end_stream]
-      frames
-    end
-
-    # Splits the HEADERS or PUSH_PROMISE frame into multiple frames if the payload size exceeds max size.
-    # @param max [Integer] The maximum size of a frame payload.
-    # @return [Array<Frame>] The splitted frames.
-    def split_headers(max)
-      return [self] if self.length <= max
-      raise "Frame type must be HEADERS or PUSH_PROMISE" unless [:headers, :push_promise].include?(self.type)
-
-      fragments = self.payload.each_byteslice(max).to_a
-      frames = fragments.map {|fragment| Frame.new(type: :continuation, flags: [], stream_id: self.stream_id, payload: fragment) }
-      frames.first.type_value = self.type_value
-      frames.first.flags = self.flags - [:end_headers]
-      frames.last.flags = self.flags & [:end_headers]
-      frames
+    # @yield [Frame] The splitted frames.
+    def split(max)
+      return yield self if @length <= max
+      first, *mid, last = @payload.chunk(max)
+      case type
+      when :data
+        yield Frame.new(type_value: 0, stream_id: @stream_id, payload: first, flags_value: @flags_value & ~1)
+        mid.each { |slice|
+          yield Frame.new(type_value: 0, stream_id: @stream_id, payload: slice, flags_value: 0)
+        }
+        yield Frame.new(type_value: 0, stream_id: @stream_id, payload: last, flags_value: @flags_value & 1)
+      when :headers, :push_promise
+        yield Frame.new(type_value: @type_value, stream_id: @stream_id, payload: first, flags_value: @flags_value & ~4)
+        mid.each { |slice|
+          yield Frame.new(type: :continuation, stream_id: @stream_id, payload: slice, flags_value: 0)
+        }
+        yield Frame.new(type: :continuation, stream_id: @stream_id, payload: last, flags_value: @flags_value & 4)
+      else
+        raise NotImplementedError.new("frame split of frame with type #{type} is not supported")
+      end
     end
 
     # Parses SETTINGS frame payload. Ignores unknown settings type (see RFC7540 6.5.2).

data/lib/plum/hpack/constants.rb

@@ -67,6 +67,8 @@ module Plum
       ["www-authenticate", ""],
     ].freeze
 
+    STATIC_TABLE_SIZE = STATIC_TABLE.size
+
     HUFFMAN_TABLE = [
       "1111111111000",
       "11111111111111111011000",

data/lib/plum/hpack/context.rb

@@ -26,10 +26,10 @@ module Plum
       def fetch(index)
         if index == 0
           raise HPACKError.new("index can't be 0")
-        elsif index <= STATIC_TABLE.size
-          STATIC_TABLE[index - 1]
+        elsif index <= STATIC_TABLE_SIZE
+            STATIC_TABLE[index - 1]
         elsif index <= STATIC_TABLE.size + @dynamic_table.size
-          @dynamic_table[index - STATIC_TABLE.size - 1]
+          @dynamic_table[index - STATIC_TABLE_SIZE - 1]
         else
           raise HPACKError.new("invalid index: #{index}")
         end
@@ -43,7 +43,7 @@ module Plum
         si = STATIC_TABLE.index &pr
         return si + 1 if si
         di = @dynamic_table.index &pr
-        return di + STATIC_TABLE.size + 1 if di
+        return di + STATIC_TABLE_SIZE + 1 if di
       end
 
       def evict

data/lib/plum/rack/cli.rb

@@ -44,6 +44,13 @@ module Plum
         ENV["RACK_ENV"] = @options[:env] if @options[:env]
         config[:debug] = @options[:debug] unless @options[:debug].nil?
         config[:server_push] = @options[:server_push] unless @options[:server_push].nil?
+        config[:threaded] = @options[:threaded] unless @options[:threaded].nil?
+
+        if @options[:fallback_legacy]
+          h, p = @options[:fallback_legacy].split(":")
+          config[:fallback_legacy_host] = h
+          config[:fallback_legacy_port] = p.to_i
+        end
 
         if @options[:socket]
           config[:listeners] << { listener: UNIXListener,
@@ -59,8 +66,8 @@ module Plum
             config[:listeners] << { listener: TLSListener,
                                     hostname: @options[:host] || "0.0.0.0",
                                     port: @options[:port] || 8080,
-                                    certificate: @options[:cert] && File.read(@options[:cert]),
-                                    certificate_key: @options[:cert] && File.read(@options[:key]) }
+                                    certificate: @options[:cert],
+                                    certificate_key: @options[:cert] && @options[:key] }
           end
         end
 
@@ -113,6 +120,14 @@ module Plum
             @options[:key] = arg
           end
 
+          o.on "--threaded", "Call the Rack application in threads (experimental)" do
+            @options[:threaded] = true
+          end
+
+          o.on "--fallback-legacy HOST:PORT", "Fallbacks if the client doesn't support HTTP/2" do |arg|
+            @options[:fallback_legacy] = arg
+          end
+
           o.on "-v", "--version", "Show version" do
             puts "plum version #{::Plum::VERSION}"
             exit(0)

data/lib/plum/rack/config.rb

@@ -6,7 +6,8 @@ module Plum
         listeners: [],
         debug: false,
         log: nil, # $stdout
-        server_push: true
+        server_push: true,
+        threaded: false
       }.freeze
 
       def initialize(config = {})

data/lib/plum/rack/dsl.rb

@@ -39,6 +39,16 @@ module Plum
         def server_push(bool)
           @config[:server_push] = !!bool
         end
+
+        def threaded(bool)
+          @config[:threaded] = !!bool
+        end
+
+        def fallback_legacy(str)
+          h, p = str.split(":")
+          @config[:fallback_legacy_host] = h
+          @config[:fallback_legacy_port] = p.to_i
+        end
       end
     end
   end

data/lib/plum/rack/listener.rb

@@ -31,17 +31,22 @@ module Plum
 
     class TLSListener < BaseListener
       def initialize(lc)
-        cert, key = lc[:certificate], lc[:certificate_key]
-        unless cert && key
-          puts "WARNING: using dummy certificate"
+        if lc[:certificate] && lc[:certificate_key]
+          cert = File.read(lc[:certificate])
+          key = File.read(lc[:certificate_key])
+        else
+          STDERR.puts "WARNING: using dummy certificate"
           cert, key = dummy_key
         end
 
         ctx = OpenSSL::SSL::SSLContext.new
         ctx.ssl_version = :TLSv1_2
         ctx.alpn_select_cb = -> protocols {
-          raise "Client does not support HTTP/2: #{protocols}" unless protocols.include?("h2")
-          "h2"
+          if protocols.include?("h2")
+            "h2"
+          else
+            protocols.first
+          end
         }
         ctx.tmp_ecdh_callback = -> (sock, ise, keyl) { OpenSSL::PKey::EC.new("prime256v1") }
         ctx.cert = OpenSSL::X509::Certificate.new(cert)
@@ -56,6 +61,7 @@ module Plum
       end
 
       def plum(sock)
+        raise ::Plum::LegacyHTTPError.new("client doesn't offered h2 with ALPN", nil) unless sock.alpn_protocol == "h2"
         ::Plum::HTTPSServerConnection.new(sock)
       end
 

data/lib/plum/rack/server.rb

@@ -47,31 +47,59 @@ module Plum
         sock = svr.accept
         Thread.new {
           begin
-            sock = sock.accept if sock.respond_to?(:accept)
-            plum = svr.plum(sock)
+            begin
+              sock = sock.accept if sock.respond_to?(:accept)
+              plum = svr.plum(sock)
 
-            con = Session.new(app: @app,
-                              plum: plum,
-                              sock: sock,
-                              logger: @logger,
-                              server_push: @config[:server_push],
-                              remote_addr: sock.peeraddr.last)
-            con.run
-          rescue Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINVAL => e # closed
-            sock.close if sock
+              con = Session.new(app: @app,
+                                plum: plum,
+                                sock: sock,
+                                logger: @logger,
+                                config: @config,
+                                remote_addr: sock.peeraddr.last)
+              con.run
+            rescue ::Plum::LegacyHTTPError => e
+              @logger.info "legacy HTTP client: #{e}"
+              handle_legacy(e, sock)
+            end
+          rescue Errno::ECONNRESET, Errno::EPROTO, Errno::EINVAL, EOFError => e # closed
           rescue StandardError => e
             log_exception(e)
+          ensure
             sock.close if sock
           end
         }
       rescue Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINVAL => e # closed
+        sock.close if sock
       rescue StandardError => e
         log_exception(e)
+        sock.close if sock
       end
 
       def log_exception(e)
         @logger.error("#{e.class}: #{e.message}\n#{e.backtrace.map { |b| "\t#{b}" }.join("\n")}")
       end
+
+      def handle_legacy(e, sock)
+        if @config[:fallback_legacy_host]
+          @logger.info "legacy HTTP: fallbacking to: #{@config[:fallback_legacy_host]}:#{@config[:fallback_legacy_port]}"
+          upstream = TCPSocket.open(@config[:fallback_legacy_host], @config[:fallback_legacy_port])
+          upstream.write(e.buf) if e.buf
+          loop do
+            ret = IO.select([sock, upstream])
+            ret[0].each { |s|
+              a = s.readpartial(65536)
+              if s == upstream
+                sock.write(a)
+              else
+                upstream.write(a)
+              end
+            }
+          end
+        end
+      ensure
+        upstream.close if upstream
+      end
     end
   end
 end

data/lib/plum/rack/session.rb

@@ -8,13 +8,14 @@ module Plum
     class Session
       attr_reader :app, :plum
 
-      def initialize(app:, plum:, sock:, logger:, server_push: true, remote_addr: "127.0.0.1")
+      def initialize(app:, plum:, sock:, logger:, config:, remote_addr: "127.0.0.1")
         @app = app
         @plum = plum
         @sock = sock
         @logger = logger
-        @server_push = server_push
+        @config = config
         @remote_addr = remote_addr
+        @request_thread = {} # used if threaded
 
         setup_plum
       end
@@ -24,22 +25,33 @@ module Plum
       end
 
       def run
-        begin
-          while !@sock.closed? && !@sock.eof?
-            @plum << @sock.readpartial(16384)
-          end
-        rescue Errno::EPIPE, Errno::ECONNRESET => e
-        rescue StandardError => e
-          @logger.error("#{e.class}: #{e.message}\n#{e.backtrace.map { |b| "\t#{b}" }.join("\n")}")
+        while !@sock.closed? && !@sock.eof?
+          @plum << @sock.readpartial(1024)
         end
+      rescue Errno::EPIPE, Errno::ECONNRESET => e
+      rescue StandardError => e
+        @logger.error("#{e.class}: #{e.message}\n#{e.backtrace.map { |b| "\t#{b}" }.join("\n")}")
+      ensure
+        @request_thread.each { |stream, thread| thread.kill }
+        stop
       end
 
       private
       def setup_plum
+        @plum.on(:frame) { |f| puts "recv:#{f.inspect}" }
+        @plum.on(:send_frame) { |f|
+          puts "send:#{f.inspect}" unless f.type == :data
+        }
         @plum.on(:connection_error) { |ex| @logger.error(ex) }
 
         # @plum.on(:stream) { |stream| @logger.debug("new stream: #{stream}") }
-        @plum.on(:stream_error) { |stream, ex| @logger.error(ex) }
+        @plum.on(:stream_error) { |stream, ex|
+          if [:cancel, :refused_stream].include?(ex.http2_error_type)
+            @logger.debug("stream was cancelled: #{stream}")
+          else
+            @logger.error(ex)
+          end
+        }
 
         reqs = {}
         @plum.on(:headers) { |stream, h|
@@ -48,25 +60,34 @@ module Plum
 
         @plum.on(:data) { |stream, d|
           reqs[stream][:data] << d # TODO: store to file?
+          check_window(stream)
         }
 
         @plum.on(:end_stream) { |stream|
-          handle_request(stream, reqs[stream][:headers], reqs[stream][:data])
+          if @config[:threaded]
+            @request_thread[stream] = Thread.new {
+              handle_request(stream, reqs[stream][:headers], reqs[stream][:data])
+            }
+          else
+            handle_request(stream, reqs[stream][:headers], reqs[stream][:data])
+          end
         }
       end
 
+      def check_window(stream)
+        ws = @plum.local_settings[:initial_window_size]
+        stream.window_update(ws) if stream.recv_remaining_window < (ws / 2)
+        @plum.window_update(ws) if @plum.recv_remaining_window < (ws / 2)
+      end
+
       def send_body(stream, body)
         begin
-          if body.is_a?(IO)
+          if body.respond_to?(:to_str)
             stream.send_data(body, end_stream: true)
-          elsif body.respond_to?(:size)
-            last = body.size - 1
-            i = 0
-            body.each { |part|
-              stream.send_data(part, end_stream: last == i)
-              i += 1
-            }
-            stream.send_data(nil, end_stream: true) if i == 0
+          elsif body.respond_to?(:readpartial) && body.respond_to?(:eof?)
+            until body.eof?
+              stream.send_data(body.readpartial(65536), end_stream: body.eof?)
+            end
           else
             body.each { |part| stream.send_data(part, end_stream: false) }
             stream.send_data(nil, end_stream: true)
@@ -77,9 +98,7 @@ module Plum
       end
 
       def extract_push(reqheaders, extheaders)
-        if @server_push &&
-            @plum.push_enabled? &&
-            pushs = extheaders["plum.serverpush"]
+        if @config[:server_push] && @plum.push_enabled? && pushs = extheaders["plum.serverpush"]
           authority = reqheaders.find { |k, v| k == ":authority" }[1]
           scheme = reqheaders.find { |k, v| k == ":scheme" }[1]
 
@@ -87,7 +106,7 @@ module Plum
             method, path = push.split(" ", 2)
             {
               ":authority" => authority,
-              ":method" => method.to_s.upcase,
+              ":method" => method.upcase,
               ":scheme" => scheme,
               ":path" => path
             }
@@ -102,21 +121,26 @@ module Plum
         r_status, r_rawheaders, r_body = @app.call(env)
         r_headers, r_extheaders = extract_headers(r_status, r_rawheaders)
 
-        stream.send_headers(r_headers, end_stream: false)
+        no_body = r_body.respond_to?(:empty?) && r_body.empty?
+
+        stream.send_headers(r_headers, end_stream: no_body)
 
         push_sts = extract_push(headers, r_extheaders).map { |preq|
           [stream.promise(preq), preq]
         }
 
-        send_body(stream, r_body)
+        send_body(stream, r_body) unless no_body
 
         push_sts.each { |st, preq|
-          penv = new_env(preq, "")
+          penv = new_env(preq, "".b)
           p_status, p_h, p_body = @app.call(penv)
-          p_headers = extract_headers(p_status, p_h)
-          st.send_headers(p_headers, end_stream: false)
-          send_body(st, p_body)
+          p_headers, _ = extract_headers(p_status, p_h)
+          pno_body = p_body.respond_to?(:empty?) && p_body.empty?
+          st.send_headers(p_headers, end_stream: pno_body)
+          send_body(st, p_body) unless pno_body
         }
+
+        @request_thread.delete(stream)
       end
 
       def new_env(h, data)
@@ -130,6 +154,7 @@ module Plum
           "rack.hijack?"      => false,
           "SCRIPT_NAME"       => "",
           "REMOTE_ADDR"       => @remote_addr,
+          "HTTP_VERSION"      => "HTTP/2.0", # Rack::CommonLogger uses
         }
 
         h.each { |k, v|
@@ -180,7 +205,6 @@ module Plum
             if "set-cookie" == key
               rbase[key] = v_.gsub("\n", "; ") # RFC 7540 8.1.2.5
             elsif !INVALID_HEADERS.member?(key)
-              key.byteshift(2) if key.start_with?("x-")
               rbase[key] = v_.tr("\n", ",") # RFC 7230 7
             end
           end

data/lib/plum/server/connection.rb

@@ -11,7 +11,7 @@ module Plum
     # Reserves a new stream to server push.
     # @param args [Hash] The argument to pass to Stram.new.
     def reserve_stream(**args)
-      next_id = @max_stream_id + (@max_stream_id.odd? ? 1 : 2)
+      next_id = @max_stream_ids[0] + 2
       stream = stream(next_id)
       stream.set_state(:reserved_local)
       stream.update_dependency(**args)

data/lib/plum/server/http_connection.rb

@@ -7,10 +7,9 @@ module Plum
 
     def initialize(sock, local_settings = {})
       require "http/parser"
-      @_headers = nil
-      @_body = String.new
-      @_http_parser = setup_parser
       @sock = sock
+      @negobuf = String.new
+      @_http_parser = setup_parser
       super(@sock.method(:write), local_settings)
     end
 
@@ -23,40 +22,44 @@ module Plum
     private
     def negotiate!
       super
-    rescue RemoteConnectionError
-      # Upgrade from HTTP/1.1
+    rescue RemoteConnectionError # Upgrade from HTTP/1.1 or legacy
+      @negobuf << @buffer
       offset = @_http_parser << @buffer
       @buffer.byteshift(offset)
     end
 
     def setup_parser
+      headers = nil
+      body = String.new
+
       parser = HTTP::Parser.new
-      parser.on_headers_complete = proc {|_headers|
-        @_headers = _headers.map {|n, v| [n.downcase, v] }.to_h
+      parser.on_headers_complete = proc { |_headers|
+        headers = _headers.map {|n, v| [n.downcase, v] }.to_h
       }
-      parser.on_body = proc {|chunk| @_body << chunk }
-      parser.on_message_complete = proc {|env|
-        connection = @_headers["connection"] || ""
-        upgrade = @_headers["upgrade"] || ""
-        settings = @_headers["http2-settings"]
+      parser.on_body = proc { |chunk| body << chunk }
+      parser.on_message_complete = proc { |env|
+        connection = headers["connection"] || ""
+        upgrade = headers["upgrade"] || ""
+        settings = headers["http2-settings"]
 
         if (connection.split(", ").sort == ["Upgrade", "HTTP2-Settings"].sort &&
             upgrade.split(", ").include?("h2c") &&
             settings != nil)
-          switch_protocol(settings)
+          switch_protocol(settings, parser, headers, body)
+          @negobuf = @_http_parser = nil
         else
-          raise LegacyHTTPError.new(@_headers, @_body, parser)
+          raise LegacyHTTPError.new("request doesn't Upgrade", @negobuf)
         end
       }
 
       parser
     end
 
-    def switch_protocol(settings)
+    def switch_protocol(settings, parser, headers, data)
       self.on(:negotiated) {
         _frame = Frame.new(type: :settings, stream_id: 0, payload: Base64.urlsafe_decode64(settings))
         receive_settings(_frame, send_ack: false) # HTTP2-Settings
-        process_first_request
+        process_first_request(parser, headers, data)
       }
 
       resp = "HTTP/1.1 101 Switching Protocols\r\n" +
@@ -68,18 +71,17 @@ module Plum
       @sock.write(resp)
     end
 
-    def process_first_request
+    def process_first_request(parser, headers, body)
       encoder = HPACK::Encoder.new(0, indexing: false) # don't pollute connection's HPACK context
       stream = stream(1)
       max_frame_size = local_settings[:max_frame_size]
-      headers = @_headers.merge({ ":method" => @_http_parser.http_method,
-                                  ":path" => @_http_parser.request_url,
-                                  ":authority" => @_headers["host"] })
-                         .reject {|n, v| ["connection", "http2-settings", "upgrade", "host"].include?(n) }
+      nheaders = headers.merge({ ":method" => parser.http_method,
+                                 ":path" => parser.request_url,
+                                 ":authority" => headers["host"] })
+                        .reject {|n, v| ["connection", "http2-settings", "upgrade", "host"].include?(n) }
 
-      headers_s = Frame.headers(1, encoder.encode(headers), :end_headers).split_headers(max_frame_size) # stream ID is 1
-      data_s = Frame.data(1, @_body, :end_stream).split_data(max_frame_size)
-      (headers_s + data_s).each {|frag| stream.receive_frame(frag) }
+      stream.receive_frame Frame.headers(1, encoder.encode(nheaders), end_headers: true)
+      stream.receive_frame Frame.data(1, body, end_stream: true)
     end
   end
 end

data/lib/plum/stream.rb

@@ -58,7 +58,6 @@ module Plum
     end
 
     # Closes this stream. Sends RST_STREAM frame to the peer.
-    # @param error_type [Symbol] The error type to be contained in the RST_STREAM frame.
     def close
       @state = :closed
       callback(:close)

data/lib/plum/stream_utils.rb

@@ -9,10 +9,8 @@ module Plum
     def promise(headers)
       stream = @connection.reserve_stream(weight: self.weight + 1, parent: self)
       encoded = @connection.hpack_encoder.encode(headers)
-      original = Frame.push_promise(id, stream.id, encoded, :end_headers)
-      original.split_headers(@connection.remote_settings[:max_frame_size]).each do |frame|
-        send frame
-      end
+      frame = Frame.push_promise(id, stream.id, encoded, end_headers: true)
+      send frame
       stream
     end
 
@@ -22,10 +20,8 @@ module Plum
     def send_headers(headers, end_stream:)
       max = @connection.remote_settings[:max_frame_size]
       encoded = @connection.hpack_encoder.encode(headers)
-      original_frame = Frame.headers(id, encoded, :end_headers, (end_stream && :end_stream || nil))
-      original_frame.split_headers(max).each do |frame|
-        send frame
-      end
+      frame = Frame.headers(id, encoded, end_headers: true, end_stream: end_stream)
+      send frame
       @state = :half_closed_local if end_stream
     end
 
@@ -35,14 +31,12 @@ module Plum
     def send_data(data, end_stream: true)
       max = @connection.remote_settings[:max_frame_size]
       if data.is_a?(IO)
-        while !data.eof? && fragment = data.readpartial(max)
-          send Frame.data(id, fragment, (end_stream && data.eof? && :end_stream))
+        until data.eof?
+          fragment = data.readpartial(max)
+          send Frame.data(id, fragment, end_stream: end_stream && data.eof?)
         end
       else
-        original = Frame.data(id, data, (end_stream && :end_stream))
-        original.split_data(max).each do |frame|
-          send frame
-        end
+        send Frame.data(id, data, end_stream: end_stream)
       end
       @state = :half_closed_local if end_stream
     end

data/lib/plum/version.rb

@@ -1,4 +1,4 @@
 # -*- frozen-string-literal: true -*-
 module Plum
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/lib/rack/handler/plum.rb

@@ -1,4 +1,6 @@
 # -*- frozen-string-literal: true -*-
+require "plum/rack"
+
 module Rack
   module Handler
     class Plum

data/test/plum/client/test_upgrade_client_session.rb

@@ -24,8 +24,8 @@ class UpgradeClientSessionTest < Minitest::Test
     sock.rio.string << Frame.settings().assemble
     sock.rio.string << Frame.settings(:ack).assemble
     res = session.request({ ":method" => "GET", ":path" => "/aa" }, "aa", {})
-    sock.rio.string << Frame.headers(3, HPACK::Encoder.new(3).encode(":status" => "200", "content-length" => "3"), :end_headers).assemble
-    sock.rio.string << Frame.data(3, "aaa", :end_stream).assemble
+    sock.rio.string << Frame.headers(3, HPACK::Encoder.new(3).encode(":status" => "200", "content-length" => "3"), end_headers: true).assemble
+    sock.rio.string << Frame.data(3, "aaa", end_stream: true).assemble
     session.succ until res.finished?
     assert(res.finished?)
     assert_equal("aaa", res.body)

data/test/plum/test_binary_string.rb

@@ -61,4 +61,10 @@ class BinaryStringTest < Minitest::Test
     ret = string.each_byteslice(3)
     assert_equal(["123", "456", "78"], ret.to_a)
   end
+
+  def test_chunk
+    string = "12345678"
+    ret = string.chunk(3)
+    assert_equal(["123", "456", "78"], ret)
+  end
 end

data/test/plum/test_connection.rb

@@ -100,4 +100,15 @@ class ConnectionTest < Minitest::Test
       }
     }
   end
+
+  def test_send_immediately_split
+    io = StringIO.new
+    con = Connection.new(io.method(:write))
+    fs = parse_frames(io) {
+      con.__send__(:send_immediately, Frame.new(type: :data, stream_id: 1, payload: "a"*16385))
+    }
+    assert_equal(2, fs.size)
+    assert_equal(16384, fs.first.length)
+    assert_equal(1, fs.last.length)
+  end
 end

data/test/plum/test_connection_utils.rb

@@ -16,7 +16,7 @@ class ServerConnectionUtilsTest < Minitest::Test
 
   def test_server_goaway
     open_server_connection {|con|
-      con << Frame.headers(3, "", :end_stream, :end_headers).assemble
+      con << Frame.headers(3, "", end_stream: true, end_headers: true).assemble
       con.goaway(:stream_closed)
 
       last = sent_frames.last

data/test/plum/test_flow_control.rb

@@ -135,17 +135,17 @@ class FlowControlTest < Minitest::Test
 
     prepare.call {|con, stream|
       con.window_update(500) # extend only connection
-      con << Frame.headers(stream.id, "", :end_headers).assemble
+      con << Frame.headers(stream.id, "", end_headers: true).assemble
       assert_stream_error(:flow_control_error) {
-        con << Frame.data(stream.id, "\x00" * 30, :end_stream).assemble
+        con << Frame.data(stream.id, "\x00" * 30, end_stream: true).assemble
       }
     }
 
     prepare.call {|con, stream|
       stream.window_update(500) # extend only stream
-      con << Frame.headers(stream.id, "", :end_headers).assemble
+      con << Frame.headers(stream.id, "", end_headers: true).assemble
       assert_connection_error(:flow_control_error) {
-        con << Frame.data(stream.id, "\x00" * 30, :end_stream).assemble
+        con << Frame.data(stream.id, "\x00" * 30, end_stream: true).assemble
       }
     }
   end
@@ -155,8 +155,8 @@ class FlowControlTest < Minitest::Test
       con = stream.connection
       con.settings(initial_window_size: 24)
       stream.window_update(1)
-      con << Frame.headers(stream.id, "", :end_headers).assemble
-      con << Frame.data(stream.id, "\x00" * 20, :end_stream).assemble
+      con << Frame.headers(stream.id, "", end_headers: true).assemble
+      con << Frame.data(stream.id, "\x00" * 20, end_stream: true).assemble
       assert_equal(4, con.recv_remaining_window)
       assert_equal(5, stream.recv_remaining_window)
       con.settings(initial_window_size: 60)

data/test/plum/test_frame_factory.rb

@@ -55,7 +55,7 @@ class FrameFactoryTest < Minitest::Test
   end
 
   def test_continuation
-    frame = Frame.continuation(123, "abc", :end_headers)
+    frame = Frame.continuation(123, "abc", end_headers: true)
     assert_frame(frame,
                  type: :continuation,
                  stream_id: 123,
@@ -74,7 +74,7 @@ class FrameFactoryTest < Minitest::Test
   end
 
   def test_headers
-    frame = Frame.headers(123, "abc", :end_stream)
+    frame = Frame.headers(123, "abc", end_stream: true)
     assert_frame(frame,
                  type: :headers,
                  stream_id: 123,
@@ -83,7 +83,7 @@ class FrameFactoryTest < Minitest::Test
   end
 
   def test_push_promise
-    frame = Frame.push_promise(345, 2, "abc", :end_headers)
+    frame = Frame.push_promise(345, 2, "abc", end_headers: true)
     assert_frame(frame,
                  type: :push_promise,
                  stream_id: 345,

data/test/plum/test_frame_utils.rb

@@ -3,30 +3,29 @@ require "test_helper"
 class FrameUtilsTest < Minitest::Test
   def test_frame_enough_short
     frame = Frame.new(type: :data, stream_id: 1, payload: "123")
-    ret = frame.split_data(3)
+    ret = frame.to_enum(:split, 3).to_a
     assert_equal(1, ret.size)
     assert_equal("123", ret.first.payload)
   end
 
   def test_frame_unknown
     frame = Frame.new(type: :settings, stream_id: 1, payload: "123")
-    assert_raises { frame.split_data(2) }
-    assert_raises { frame.split_headers(2) }
+    assert_raises(NotImplementedError) { frame.split(2) }
   end
 
   def test_frame_data
     frame = Frame.new(type: :data, flags: [:end_stream], stream_id: 1, payload: "12345")
-    ret = frame.split_data(3)
-    assert_equal(2, ret.size)
-    assert_equal("123", ret.first.payload)
+    ret = frame.to_enum(:split, 2).to_a
+    assert_equal(3, ret.size)
+    assert_equal("12", ret.first.payload)
     assert_equal([], ret.first.flags)
-    assert_equal("45", ret.last.payload)
+    assert_equal("5", ret.last.payload)
     assert_equal([:end_stream], ret.last.flags)
   end
 
   def test_frame_headers
     frame = Frame.new(type: :headers, flags: [:priority, :end_stream, :end_headers], stream_id: 1, payload: "1234567")
-    ret = frame.split_headers(3)
+    ret = frame.to_enum(:split, 3).to_a
     assert_equal(3, ret.size)
     assert_equal("123", ret[0].payload)
     assert_equal([:end_stream, :priority], ret[0].flags)

data/test/plum/test_stream.rb

@@ -28,7 +28,7 @@ class StreamTest < Minitest::Test
       }
 
       assert_stream_error(:frame_size_error) {
-        con << Frame.headers(1, "", :end_headers).assemble
+        con << Frame.headers(1, "", end_headers: true).assemble
       }
 
       last = sent_frames.last
@@ -43,7 +43,7 @@ class StreamTest < Minitest::Test
       stream = nil
       con.on(:headers) { |s| stream = s }
 
-      con << Frame.headers(1, "", :end_headers).assemble
+      con << Frame.headers(1, "", end_headers: true).assemble
       assert_raises(LocalStreamError) {
         con << Frame.rst_stream(1, :frame_size_error).assemble
       }

data/test/utils/server.rb

@@ -20,7 +20,7 @@ module ServerUtils
       con = open_server_connection
     end
 
-    @_stream = con.instance_eval { stream(((@max_stream_id+1)/2)*2+1) }
+    @_stream = con.instance_eval { stream(@max_stream_ids[1] + 2) }
     @_stream.set_state(state)
     @_stream.update_dependency(**kwargs)
     if block_given?
@@ -39,8 +39,7 @@ module ServerUtils
     frames
   end
 
-  def capture_frames(con = nil, &blk)
-    io = (con || @_con).sock
+  def parse_frames(io, &blk)
     pos = io.string.bytesize
     blk.call
     resp = io.string.byteslice(pos, io.string.bytesize - pos).force_encoding(Encoding::BINARY)
@@ -51,8 +50,8 @@ module ServerUtils
     frames
   end
 
-  def capture_frame(con = nil, &blk)
-    frames = capture_frames(con, &blk)
+  def parse_frame(io, &blk)
+    frames = capture_frames(io, &blk)
     assert_equal(1, frames.size, "Supplied block sent no frames or more than 1 frame")
     frames.first
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plum
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - rhenium
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-10 00:00:00.000000000 Z
+date: 2015-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler