plum 0.1.3 → 0.2.0

data/lib/plum/client/client_session.rb

@@ -0,0 +1,91 @@
+# -*- frozen-string-literal: true -*-
+module Plum
+  # HTTP/2 client session.
+  class ClientSession
+    HTTP2_DEFAULT_SETTINGS = {
+      enable_push: 0, # TODO: api?
+      initial_window_size: 2 ** 30, # TODO
+    }
+
+    attr_reader :plum
+
+    def initialize(socket, config)
+      @socket = socket
+      @config = config
+      @http2_settings = HTTP2_DEFAULT_SETTINGS.merge(@config[:http2_settings])
+
+      @plum = setup_plum
+      @responses = Set.new
+    end
+
+    def succ
+      @plum << @socket.readpartial(16384)
+    rescue => e
+      fail(e)
+    end
+
+    def empty?
+      @responses.empty?
+    end
+
+    def close
+      @closed = true
+      @responses.each(&:_fail)
+      @responses.clear
+      @plum.close
+    end
+
+    def request(headers, body, options, &headers_cb)
+      headers = { ":method" => nil,
+                  ":path" => nil,
+                  ":authority" => @config[:hostname],
+                  ":scheme" => @config[:scheme]
+      }.merge(headers)
+
+      response = Response.new
+      @responses << response
+      stream = @plum.open_stream
+      stream.send_headers(headers, end_stream: !body)
+      stream.send_data(body, end_stream: true) if body
+
+      stream.on(:headers) { |resp_headers_raw|
+        response._headers(resp_headers_raw)
+        headers_cb.call(response) if headers_cb
+      }
+      stream.on(:data) { |chunk|
+        response._chunk(chunk)
+        check_window(stream)
+      }
+      stream.on(:end_stream) {
+        response._finish
+        @responses.delete(response)
+      }
+      stream.on(:stream_error) { |ex|
+        response._fail
+        raise ex
+      }
+      response
+    end
+
+    private
+    def fail(exception)
+      close
+      raise exception
+    end
+
+    def setup_plum
+      plum = ClientConnection.new(@socket.method(:write), @http2_settings)
+      plum.on(:connection_error) { |ex|
+        fail(ex)
+      }
+      plum.window_update(@http2_settings[:initial_window_size])
+      plum
+    end
+
+    def check_window(stream)
+      ws = @http2_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
+  end
+end

data/lib/plum/client/connection.rb

@@ -0,0 +1,19 @@
+# -*- frozen-string-literal: true -*-
+using Plum::BinaryString
+module Plum
+  class ClientConnection < Connection
+    def initialize(writer, local_settings = {})
+      super(writer, local_settings)
+
+      writer.call(CLIENT_CONNECTION_PREFACE)
+      settings(local_settings)
+      @state = :waiting_settings
+    end
+
+    # Create a new stream for HTTP request.
+    def open_stream
+      next_id = @max_stream_id + (@max_stream_id.even? ? 1 : 2)
+      stream(next_id)
+    end
+  end
+end

data/lib/plum/client/legacy_client_session.rb

@@ -0,0 +1,118 @@
+# -*- frozen-string-literal: true -*-
+module Plum
+  # HTTP/1.x client session.
+  class LegacyClientSession
+    # Creates a new HTTP/1.1 client session
+    def initialize(socket, config)
+      require "http/parser"
+      @socket = socket
+      @config = config
+
+      @parser = setup_parser
+      @requests = []
+      @response = nil
+      @headers_callback = nil
+    end
+
+    def succ
+      @parser << @socket.readpartial(16384)
+    rescue => e # including HTTP::Parser::Error
+      fail(e)
+    end
+
+    def empty?
+      !@response
+    end
+
+    def close
+      @closed = true
+      @response._fail if @response
+    end
+
+    def request(headers, body, options, &headers_cb)
+      headers["host"] = headers[":authority"] || headers["host"] || @config[:hostname]
+      if body
+        if headers["content-length"] || headers["transfer-encoding"]
+          chunked = false
+        else
+          chunked = true
+          headers["transfer-encoding"] = "chunked"
+        end
+      end
+
+      response = Response.new
+      @requests << [response, headers, body, chunked, headers_cb]
+      consume_queue
+      response
+    end
+
+    private
+    def fail(exception)
+      close
+      raise exception
+    end
+
+    def consume_queue
+      return if @response || @requests.empty?
+
+      response, headers, body, chunked, cb = @requests.shift
+      @response = response
+      @headers_callback = cb
+
+      @socket << construct_request(headers)
+
+      if body
+        if chunked
+          read_object(body) { |chunk|
+            @socket << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n"
+          }
+        else
+          read_object(body) { |chunk| @socket << chunk }
+        end
+      end
+    end
+
+    def construct_request(headers)
+      out = String.new
+      out << "%s %s HTTP/1.1\r\n" % [headers[":method"], headers[":path"]]
+      headers.each { |key, value|
+        next if key.start_with?(":") # HTTP/2 psuedo headers
+        out << "%s: %s\r\n" % [key, value]
+      }
+      out << "\r\n"
+    end
+
+    def read_object(body)
+      if body.is_a?(String)
+        yield body
+      else # IO
+        until body.eof?
+          yield body.readpartial(1024)
+        end
+      end
+    end
+
+    def setup_parser
+      parser = HTTP::Parser.new
+      parser.on_headers_complete = proc {
+        resp_headers = parser.headers.map { |key, value| [key.downcase, value] }.to_h
+        @response._headers({ ":status" => parser.status_code.to_s }.merge(resp_headers))
+        @headers_callback.call(@response) if @headers_callback
+      }
+
+      parser.on_body = proc { |chunk|
+        @response._chunk(chunk)
+      }
+
+      parser.on_message_complete = proc { |env|
+        @response._finish
+        @response = nil
+        @headers_callback = nil
+        close unless parser.keep_alive?
+        consume_queue
+      }
+
+      parser
+    end
+  end
+end

data/lib/plum/client/response.rb

@@ -0,0 +1,100 @@
+# -*- frozen-string-literal: true -*-
+module Plum
+  class Response
+    # The response headers
+    # @return [Hash<String, String>]
+    attr_reader :headers
+
+    # @api private
+    def initialize
+      @body = Queue.new
+      @finished = false
+      @failed = false
+      @body = []
+    end
+
+    # Returns the HTTP status code.
+    # @return [String] the HTTP status code
+    def status
+      @headers && @headers[":status"]
+    end
+
+    # Returns the header value that correspond to the header name.
+    # @param key [String] the header name
+    # @return [String] the header value
+    def [](key)
+      @headers[key.to_s.downcase]
+    end
+
+    # Returns whether the response is complete or not.
+    # @return [Boolean]
+    def finished?
+      @finished
+    end
+
+    # Returns whether the request has failed or not.
+    # @return [Boolean]
+    def failed?
+      @failed
+    end
+
+    # Set callback tha called when received a chunk of response body.
+    # @yield [chunk] A chunk of the response body.
+    def on_chunk(&block)
+      raise "Body already read" if @on_chunk
+      raise ArgumentError, "block must be given" unless block_given?
+      @on_chunk = block
+      unless @body.empty?
+        @body.each(&block)
+        @body.clear
+      end
+    end
+
+    # Set callback that will be called when the response finished.
+    def on_finish(&block)
+      raise ArgumentError, "block must be given" unless block_given?
+      if finished?
+        block.call
+      else
+        @on_finish = block
+      end
+    end
+
+    # Returns the complete response body. Use #each_body instead if the body can be very large.
+    # @return [String] the whole response body
+    def body
+      raise "Body already read" if @on_chunk
+      if finished?
+        @body.join
+      else
+        raise "Response body is not complete"
+      end
+    end
+
+    # @api private
+    def _headers(raw_headers)
+      # response headers should not have duplicates
+      @headers = raw_headers.to_h.freeze
+    end
+
+    # @api private
+    def _chunk(chunk)
+      if @on_chunk
+        @on_chunk.call(chunk)
+      else
+        @body << chunk
+      end
+    end
+
+    # @api private
+    def _finish
+      @finished = true
+      @on_finish.call if @on_finish
+    end
+
+    # @api private
+    def _fail
+      @failed = true
+    end
+  end
+end

data/lib/plum/client/upgrade_client_session.rb

@@ -0,0 +1,46 @@
+# -*- frozen-string-literal: true -*-
+module Plum
+  # Try upgrade to HTTP/2
+  class UpgradeClientSession
+    def initialize(socket, config)
+      prepare_session(socket, config)
+    end
+
+    def succ
+      @session.succ
+    end
+
+    def empty?
+      @session.empty?
+    end
+
+    def close
+      @session.close
+    end
+
+    def request(headers, body, options, &headers_cb)
+      @session.request(headers, body, options, &headers_cb)
+    end
+
+    private
+    def prepare_session(socket, config)
+      lcs = LegacyClientSession.new(socket, config)
+      opt_res = lcs.request({ ":method" => "OPTIONS",
+                              ":path" => "*",
+                              "User-Agent" => config[:user_agent],
+                              "Connection" => "Upgrade, HTTP2-Settings",
+                              "Upgrade" => "h2c",
+                              "HTTP2-Settings" => "" }, nil, {})
+      lcs.succ until opt_res.finished?
+
+      if opt_res.status == "101"
+        lcs.close
+        @session = ClientSession.new(socket, config)
+        @session.plum.stream(1).set_state(:half_closed_local)
+      else
+        @session = lcs
+      end
+    end
+  end
+end
+

data/lib/plum/connection.rb

@@ -23,23 +23,23 @@ module Plum
     attr_reader :state, :streams
 
     def initialize(writer, local_settings = {})
+      @state = :open
       @writer = writer
       @local_settings = Hash.new {|hash, key| DEFAULT_SETTINGS[key] }.merge!(local_settings)
       @remote_settings = Hash.new {|hash, key| DEFAULT_SETTINGS[key] }
       @buffer = String.new
       @streams = {}
-      @state = :negotiation
       @hpack_decoder = HPACK::Decoder.new(@local_settings[:header_table_size])
       @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_odd_stream_id = 0
-      @max_even_stream_id = 0
+      @max_stream_id = 0
     end
-    private :initialize
 
     # Emits :close event. Doesn't actually close socket.
     def close
+      return if @state == :closed
+      @state = :closed
       # TODO: server MAY wait streams
       callback(:close)
     end
@@ -47,80 +47,69 @@ module Plum
     # Receives the specified data and process.
     # @param new_data [String] The data received from the peer.
     def receive(new_data)
+      return if @state == :closed
       return if new_data.empty?
       @buffer << new_data
-
-      negotiate! if @state == :negotiation
-
-      if @state != :negotiation
-        while frame = Frame.parse!(@buffer)
-          callback(:frame, frame)
-          receive_frame(frame)
-        end
-      end
-    rescue ConnectionError => e
+      consume_buffer
+    rescue RemoteConnectionError => e
       callback(:connection_error, e)
       goaway(e.http2_error_type)
       close
     end
     alias << receive
 
-    # Reserves a new stream to server push.
-    # @param args [Hash] The argument to pass to Stram.new.
-    def reserve_stream(**args)
-      next_id = @max_even_stream_id + 2
-      stream = new_stream(next_id, state: :reserved_local, **args)
-      stream
-    end
-
-    private
-    def send_immediately(frame)
-      callback(:send_frame, frame)
-      @writer.call(frame.assemble)
-    end
+    # Returns a Stream object with the specified ID.
+    # @param stream_id [Integer] the stream id
+    # @return [Stream] the stream
+    def stream(stream_id)
+      raise ArgumentError, "stream_id can't be 0" if stream_id == 0
 
-    def negotiate!
-      unless CLIENT_CONNECTION_PREFACE.start_with?(@buffer.byteslice(0, 24))
-        raise ConnectionError.new(:protocol_error) # (MAY) send GOAWAY. sending.
+      stream = @streams[stream_id]
+      if stream
+        if stream.state == :idle && stream.id < @max_stream_id
+          stream.set_state(:closed_implicitly)
+        end
+      elsif stream_id > @max_stream_id
+        @max_stream_id = stream_id
+        stream = Stream.new(self, stream_id, state: :idle)
+        callback(:stream, stream)
+        @streams[stream_id] = stream
+      else
+        stream = Stream.new(self, stream_id, state: :closed_implicitly)
+        callback(:stream, stream)
       end
 
-      if @buffer.bytesize >= 24
-        @buffer.byteshift(24)
-        @state = :waiting_settings
-        settings(@local_settings)
-      end
+      stream
     end
 
-    def new_stream(stream_id, **args)
-      if stream_id.even?
-        @max_even_stream_id = stream_id
-      else
-        @max_odd_stream_id = stream_id
+    private
+    def consume_buffer
+      while frame = Frame.parse!(@buffer)
+        callback(:frame, frame)
+        receive_frame(frame)
       end
+    end
 
-      stream = Stream.new(self, stream_id, **args)
-      @streams[stream_id] = stream
-      callback(:stream, stream)
-      stream
+    def send_immediately(frame)
+      callback(:send_frame, frame)
+      @writer.call(frame.assemble)
     end
 
     def validate_received_frame(frame)
       if @state == :waiting_settings && frame.type != :settings
-        raise ConnectionError.new(:protocol_error)
+        raise RemoteConnectionError.new(:protocol_error)
       end
 
       if @state == :waiting_continuation
         if frame.type != :continuation || frame.stream_id != @continuation_id
-          raise ConnectionError.new(:protocol_error)
+          raise RemoteConnectionError.new(:protocol_error)
         end
-
         if frame.end_headers?
           @state = :open
-          @continuation_id = nil
         end
       end
 
-      if frame.type == :headers
+      if frame.type == :headers || frame.type == :push_promise
         if !frame.end_headers?
           @state = :waiting_continuation
           @continuation_id = frame.stream_id
@@ -135,20 +124,13 @@ module Plum
       if frame.stream_id == 0
         receive_control_frame(frame)
       else
-        unless stream = @streams[frame.stream_id]
-          if frame.stream_id.even? || @max_odd_stream_id >= frame.stream_id
-            raise Plum::ConnectionError.new(:protocol_error)
-          end
-
-          stream = new_stream(frame.stream_id)
-        end
-        stream.receive_frame(frame)
+        stream(frame.stream_id).receive_frame(frame)
       end
     end
 
     def receive_control_frame(frame)
       if frame.length > @local_settings[:max_frame_size]
-        raise ConnectionError.new(:frame_size_error)
+        raise RemoteConnectionError.new(:frame_size_error)
       end
 
       case frame.type
@@ -159,11 +141,9 @@ module Plum
       when :ping
         receive_ping(frame)
       when :goaway
-        callback(:goaway, frame)
-        goaway
-        close
+        receive_goaway(frame)
       when :data, :headers, :priority, :rst_stream, :push_promise, :continuation
-        raise Plum::ConnectionError.new(:protocol_error)
+        raise Plum::RemoteConnectionError.new(:protocol_error)
       else
         # MUST ignore unknown frame type.
       end
@@ -171,11 +151,11 @@ module Plum
 
     def receive_settings(frame, send_ack: true)
       if frame.ack?
-        raise ConnectionError.new(:frame_size_error) if frame.length != 0
+        raise RemoteConnectionError.new(:frame_size_error) if frame.length != 0
         callback(:settings_ack)
         return
       else
-        raise ConnectionError.new(:frame_size_error) if frame.length % 6 != 0
+        raise RemoteConnectionError.new(:frame_size_error) if frame.length % 6 != 0
       end
 
       old_remote_settings = @remote_settings.dup
@@ -198,7 +178,7 @@ module Plum
     end
 
     def receive_ping(frame)
-      raise Plum::ConnectionError.new(:frame_size_error) if frame.length != 8
+      raise Plum::RemoteConnectionError.new(:frame_size_error) if frame.length != 8
 
       if frame.ack?
         callback(:ping_ack)
@@ -208,5 +188,18 @@ module Plum
         send_immediately Frame.ping(:ack, opaque_data)
       end
     end
+
+    def receive_goaway(frame)
+      callback(:goaway, frame)
+      goaway
+      close
+
+      last_id = frame.payload.uint32(0)
+      error_code = frame.payload.uint32(4)
+      message = frame.payload.byteslice(8, frame.length - 8)
+      if error_code > 0
+        raise LocalConnectionError.new(HTTPError::ERROR_CODES.key(error_code), message)
+      end
+    end
   end
 end