plum 0.1.3 → 0.2.0

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_odd_stream_id > @max_even_stream_id ? @max_odd_stream_id : @max_even_stream_id
+      last_id = @max_stream_id
       send_immediately Frame.goaway(last_id, error_type)
     end
 

data/lib/plum/errors.rb

@@ -31,9 +31,6 @@ module Plum
       ERROR_CODES[@http2_error_type]
     end
   end
-  class ConnectionError < HTTPError; end
-  class StreamError < HTTPError; end
-
   class LegacyHTTPError < Error
     attr_reader :headers, :data, :parser
 
@@ -43,4 +40,11 @@ module Plum
       @parser = parser
     end
   end
+
+  class RemoteHTTPError < HTTPError; end
+  class RemoteConnectionError < RemoteHTTPError; end
+  class RemoteStreamError < RemoteHTTPError; end
+  class LocalHTTPError < HTTPError; end
+  class LocalConnectionError < LocalHTTPError; end
+  class LocalStreamError < LocalHTTPError; end
 end

data/lib/plum/flow_control.rb

@@ -65,7 +65,7 @@ module Plum
       if frame.type == :data
         @recv_remaining_window -= frame.length
         if @recv_remaining_window < 0
-          local_error = (Connection === self) ? ConnectionError : StreamError
+          local_error = (Connection === self) ? RemoteConnectionError : RemoteStreamError
           raise local_error.new(:flow_control_error)
         end
       end
@@ -82,7 +82,7 @@ module Plum
 
     def receive_window_update(frame)
       if frame.length != 4
-        raise Plum::ConnectionError.new(:frame_size_error)
+        raise Plum::RemoteConnectionError.new(:frame_size_error)
       end
 
       r_wsi = frame.payload.uint32
@@ -90,7 +90,7 @@ module Plum
       wsi = r_wsi # & ~(1 << 31)
 
       if wsi == 0
-        local_error = (Connection === self) ? ConnectionError : StreamError
+        local_error = (Connection === self) ? RemoteConnectionError : RemoteStreamError
         raise local_error.new(:protocol_error)
       end
 

data/lib/plum/rack/listener.rb

@@ -25,7 +25,7 @@ module Plum
       end
 
       def plum(sock)
-        ::Plum::HTTPConnection.new(sock)
+        ::Plum::HTTPServerConnection.new(sock)
       end
     end
 
@@ -56,7 +56,7 @@ module Plum
       end
 
       def plum(sock)
-        ::Plum::HTTPSConnection.new(sock)
+        ::Plum::HTTPSServerConnection.new(sock)
       end
 
       private
@@ -116,7 +116,7 @@ module Plum
       end
 
       def plum(sock)
-        ::Plum::HTTPSConnection.new(sock)
+        ::Plum::HTTPSServerConnection.new(sock)
       end
     end
   end

data/lib/plum/rack/server.rb

@@ -52,6 +52,7 @@ module Plum
 
             con = Session.new(app: @app,
                               plum: plum,
+                              sock: sock,
                               logger: @logger,
                               server_push: @config[:server_push],
                               remote_addr: sock.peeraddr.last)

data/lib/plum/rack/session.rb

@@ -8,9 +8,10 @@ module Plum
     class Session
       attr_reader :app, :plum
 
-      def initialize(app:, plum:, logger:, server_push: true, remote_addr: "127.0.0.1")
+      def initialize(app:, plum:, sock:, logger:, server_push: true, remote_addr: "127.0.0.1")
         @app = app
         @plum = plum
+        @sock = sock
         @logger = logger
         @server_push = server_push
         @remote_addr = remote_addr
@@ -24,7 +25,9 @@ module Plum
 
       def run
         begin
-          @plum.run
+          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")}")

data/lib/plum/server/connection.rb

@@ -0,0 +1,42 @@
+# -*- frozen-string-literal: true -*-
+using Plum::BinaryString
+module Plum
+  class ServerConnection < Connection
+    def initialize(writer, local_settings = {})
+      super(writer, local_settings)
+
+      @state = :waiting_preface
+    end
+
+    # 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)
+      stream = stream(next_id)
+      stream.set_state(:reserved_local)
+      stream.update_dependency(**args)
+      stream
+    end
+
+    private
+    def consume_buffer
+      if @state == :waiting_preface
+        negotiate!
+      end
+
+      super
+    end
+
+    def negotiate!
+      unless CLIENT_CONNECTION_PREFACE.start_with?(@buffer.byteslice(0, 24))
+        raise RemoteConnectionError.new(:protocol_error) # (MAY) send GOAWAY. sending.
+      end
+
+      if @buffer.bytesize >= 24
+        @buffer.byteshift(24)
+        settings(@local_settings)
+        @state = :waiting_settings
+      end
+    end
+  end
+end

data/lib/plum/{http_connection.rb → server/http_connection.rb}

@@ -2,7 +2,7 @@
 using Plum::BinaryString
 
 module Plum
-  class HTTPConnection < Connection
+  class HTTPServerConnection < ServerConnection
     attr_reader :sock
 
     def initialize(sock, local_settings = {})
@@ -14,13 +14,6 @@ module Plum
       super(@sock.method(:write), local_settings)
     end
 
-    # Starts communication with the peer. It blocks until the io is closed, or reaches EOF.
-    def run
-      while !@sock.closed? && !@sock.eof?
-        self << @sock.readpartial(1024)
-      end
-    end
-
     # Closes the socket.
     def close
       super
@@ -30,7 +23,7 @@ module Plum
     private
     def negotiate!
       super
-    rescue ConnectionError
+    rescue RemoteConnectionError
       # Upgrade from HTTP/1.1
       offset = @_http_parser << @buffer
       @buffer.byteshift(offset)
@@ -66,10 +59,10 @@ module Plum
         process_first_request
       }
 
-      resp = "HTTP/1.1 101 Switching Protocols\r\n"
-             "Connection: Upgrade\r\n"
-             "Upgrade: h2c\r\n"
-             "Server: plum/#{Plum::VERSION}\r\n"
+      resp = "HTTP/1.1 101 Switching Protocols\r\n" +
+             "Connection: Upgrade\r\n" +
+             "Upgrade: h2c\r\n" +
+             "Server: plum/#{Plum::VERSION}\r\n" +
              "\r\n"
 
       @sock.write(resp)
@@ -77,7 +70,7 @@ module Plum
 
     def process_first_request
       encoder = HPACK::Encoder.new(0, indexing: false) # don't pollute connection's HPACK context
-      stream = new_stream(1)
+      stream = stream(1)
       max_frame_size = local_settings[:max_frame_size]
       headers = @_headers.merge({ ":method" => @_http_parser.http_method,
                                   ":path" => @_http_parser.request_url,

data/lib/plum/{https_connection.rb → server/https_connection.rb}

@@ -1,26 +1,19 @@
 # -*- frozen-string-literal: true -*-
 module Plum
-  class HTTPSConnection < Connection
+  class HTTPSServerConnection < ServerConnection
     attr_reader :sock
 
     def initialize(sock, local_settings = {})
       @sock = sock
       super(@sock.method(:write), local_settings)
-    end
 
-    # Starts communication with the peer. It blocks until the io is closed, or reaches EOF.
-    def run
       if @sock.respond_to?(:cipher) # OpenSSL::SSL::SSLSocket-like
         if CIPHER_BLACKLIST.include?(@sock.cipher.first) # [cipher-suite, ssl-version, keylen, alglen]
           on(:negotiated) {
-            raise ConnectionError.new(:inadequate_security)
+            raise RemoteConnectionError.new(:inadequate_security)
           }
         end
       end
-
-      while !@sock.closed? && !@sock.eof?
-        self << @sock.readpartial(1024)
-      end
     end
 
     # Closes the socket.

data/lib/plum/stream.rb

@@ -44,30 +44,34 @@ module Plum
         receive_window_update(frame)
       when :continuation
         receive_continuation(frame)
-      when :ping, :goaway, :settings, :push_promise
-        raise ConnectionError.new(:protocol_error) # stream_id MUST be 0x00
+      when :push_promise
+        receive_push_promise(frame)
+      when :ping, :goaway, :settings
+        raise RemoteConnectionError.new(:protocol_error) # stream_id MUST be 0x00
       else
         # MUST ignore unknown frame
       end
-    rescue StreamError => e
+    rescue RemoteStreamError => e
       callback(:stream_error, e)
-      close(e.http2_error_type)
+      send_immediately Frame.rst_stream(id, e.http2_error_type)
+      close
     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(error_type = :no_error)
+    def close
       @state = :closed
-      send_immediately Frame.rst_stream(id, error_type)
+      callback(:close)
     end
 
-    private
-    def send_immediately(frame)
-      @connection.send(frame)
+    # @api private
+    def set_state(state)
+      @state = state
     end
 
+    # @api private
     def update_dependency(weight: nil, parent: nil, exclusive: nil)
-      raise StreamError.new(:protocol_error, "A stream cannot depend on itself.") if parent == self
+      raise RemoteStreamError.new(:protocol_error, "A stream cannot depend on itself.") if parent == self
 
       if weight
         @weight = weight
@@ -91,12 +95,17 @@ module Plum
       end
     end
 
+    private
+    def send_immediately(frame)
+      @connection.send(frame)
+    end
+
     def validate_received_frame(frame)
       if frame.length > @connection.local_settings[:max_frame_size]
         if [:headers, :push_promise, :continuation].include?(frame.type)
-          raise ConnectionError.new(:frame_size_error)
+          raise RemoteConnectionError.new(:frame_size_error)
         else
-          raise StreamError.new(:frame_size_error)
+          raise RemoteStreamError.new(:frame_size_error)
         end
       end
     end
@@ -108,13 +117,13 @@ module Plum
 
     def receive_data(frame)
       if @state != :open && @state != :half_closed_local
-        raise StreamError.new(:stream_closed)
+        raise RemoteStreamError.new(:stream_closed)
       end
 
       if frame.padded?
         padding_length = frame.payload.uint8
         if padding_length >= frame.length
-          raise ConnectionError.new(:protocol_error, "padding is too long")
+          raise RemoteConnectionError.new(:protocol_error, "padding is too long")
         end
         callback(:data, frame.payload.byteslice(1, frame.length - padding_length - 1))
       else
@@ -141,7 +150,7 @@ module Plum
       end
 
       if padding_length > payload.bytesize
-        raise ConnectionError.new(:protocol_error, "padding is too long")
+        raise RemoteConnectionError.new(:protocol_error, "padding is too long")
       end
 
       frames.each do |frame|
@@ -151,7 +160,7 @@ module Plum
       begin
         decoded_headers = @connection.hpack_decoder.decode(payload)
       rescue => e
-        raise ConnectionError.new(:compression_error, e)
+        raise RemoteConnectionError.new(:compression_error, e)
       end
 
       callback(:headers, decoded_headers)
@@ -161,11 +170,15 @@ module Plum
 
     def receive_headers(frame)
       if @state == :reserved_local
-        raise ConnectionError.new(:protocol_error)
+        raise RemoteConnectionError.new(:protocol_error)
       elsif @state == :half_closed_remote
-        raise StreamError.new(:stream_closed)
+        raise RemoteStreamError.new(:stream_closed)
       elsif @state == :closed
-        raise ConnectionError.new(:stream_closed)
+        raise RemoteConnectionError.new(:stream_closed)
+      elsif @state == :closed_implicitly
+        raise RemoteConnectionError.new(:protocol_error)
+      elsif @state == :idle && self.id.even?
+        raise RemoteConnectionError.new(:protocol_error)
       end
 
       @state = :open
@@ -178,6 +191,18 @@ module Plum
       end
     end
 
+    def receive_push_promise(frame)
+      raise NotImplementedError
+
+      if promised_stream.state == :closed_implicitly
+        # 5.1.1 An endpoint that receives an unexpected stream identifier MUST respond with a connection error of type PROTOCOL_ERROR.
+        raise RemoteConnectionError.new(:protocol_error)
+      elsif promised_id.odd?
+        # 5.1.1 Streams initiated by the server MUST use even-numbered stream identifiers.
+        raise RemoteConnectionError.new(:protocol_error)
+      end
+    end
+
     def receive_continuation(frame)
       # state error mustn't happen: server_connection validates
       @continuation << frame
@@ -190,7 +215,7 @@ module Plum
 
     def receive_priority(frame)
       if frame.length != 5
-        raise StreamError.new(:frame_size_error)
+        raise RemoteStreamError.new(:frame_size_error)
       end
       receive_priority_payload(frame.payload)
     end
@@ -206,13 +231,18 @@ module Plum
 
     def receive_rst_stream(frame)
       if frame.length != 4
-        raise ConnectionError.new(:frame_size_error)
+        raise RemoteConnectionError.new(:frame_size_error)
       elsif @state == :idle
-        raise ConnectionError.new(:protocol_error)
+        raise RemoteConnectionError.new(:protocol_error)
       end
-
-      callback(:rst_stream, frame)
       @state = :closed # MUST NOT send RST_STREAM
+
+      error_code = frame.payload.uint32
+      if error_code > 0
+        raise LocalStreamError.new(HTTPError::ERROR_CODES.key(error_code))
+      else
+        callback(:rst_stream, frame)
+      end
     end
 
     # override EventEmitter

data/lib/plum/stream_utils.rb

@@ -3,18 +3,6 @@ using Plum::BinaryString
 
 module Plum
   module StreamUtils
-    # Responds to a HTTP request.
-    # @param headers [Enumerable<String, String>] The response headers.
-    # @param body [String, IO] The response body.
-    def respond(headers, body = nil, end_stream: true) # TODO: priority, padding
-      if body
-        send_headers(headers, end_stream: false)
-        send_data(body, end_stream: end_stream)
-      else
-        send_headers(headers, end_stream: end_stream)
-      end
-    end
-
     # Reserves a stream to server push. Sends PUSH_PROMISE and create new stream.
     # @param headers [Enumerable<String, String>] The *request* headers. It must contain all of them: ':authority', ':method', ':scheme' and ':path'.
     # @return [Stream] The stream to send push response.

data/lib/plum/version.rb

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

data/plum.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["rhenium"]
   spec.email         = ["k@rhe.jp"]
 
-  spec.summary       = %q{A minimal implementation of HTTP/2 server.}
+  spec.summary       = %q{An HTTP/2 Library for Ruby}
   spec.description   = spec.summary
   spec.homepage      = "https://github.com/rhenium/plum"
   spec.license       = "MIT"
@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rack"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "yard"
-  spec.add_development_dependency "minitest", "~> 5.7.0"
+  spec.add_development_dependency "minitest", "~> 5.8.0"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "codeclimate-test-reporter"
   spec.add_development_dependency "guard"