httpx 0.11.3 → 0.14.0

data/lib/httpx/plugins/stream.rb

@@ -1,10 +1,99 @@
 # frozen_string_literal: true
 
 module HTTPX
+  class StreamResponse
+    def initialize(request, session, connections)
+      @request = request
+      @session = session
+      @connections = connections
+      @options = @request.options
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block_given?
+
+      raise Error, "response already streamed" if @response
+
+      @request.stream = self
+
+      begin
+        @on_chunk = block
+
+        if @request.response
+          # if we've already started collecting the payload, yield it first
+          # before proceeding
+          body = @request.response.body
+
+          body.each do |chunk|
+            on_chunk(chunk)
+          end
+        end
+
+        response.raise_for_status
+        response.close
+      ensure
+        @on_chunk = nil
+      end
+    end
+
+    def each_line
+      return enum_for(__method__) unless block_given?
+
+      line = +""
+
+      each do |chunk|
+        line << chunk
+
+        while (idx = line.index("\n"))
+          yield line.byteslice(0..idx - 1)
+
+          line = line.byteslice(idx + 1..-1)
+        end
+      end
+    end
+
+    # This is a ghost method. It's to be used ONLY internally, when processing streams
+    def on_chunk(chunk)
+      raise NoMethodError unless @on_chunk
+
+      @on_chunk.call(chunk)
+    end
+
+    # :nocov:
+    def inspect
+      "#<StreamResponse:#{object_id}>"
+    end
+    # :nocov:
+
+    def to_s
+      response.to_s
+    end
+
+    private
+
+    def response
+      @session.__send__(:receive_requests, [@request], @connections, @options) until @request.response
+
+      @request.response
+    end
+
+    def respond_to_missing?(meth, *args)
+      response.respond_to?(meth, *args) || super
+    end
+
+    def method_missing(meth, *args, &block)
+      return super unless response.respond_to?(meth)
+
+      response.__send__(meth, *args, &block)
+    end
+  end
+
   module Plugins
     #
     # This plugin adds support for stream response (text/event-stream).
     #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Stream
+    #
     module Stream
       module InstanceMethods
         private
@@ -13,10 +102,13 @@ module HTTPX
           return super(*args, **options) unless stream
 
           requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
-
           raise Error, "only 1 response at a time is supported for streaming requests" unless requests.size == 1
 
-          StreamResponse.new(requests.first, self)
+          request = requests.first
+
+          connections = _send_requests(requests, request.options)
+
+          StreamResponse.new(request, self, connections)
         end
       end
 
@@ -31,7 +123,7 @@ module HTTPX
       end
 
       module ResponseBodyMethods
-        def initialize(*, **)
+        def initialize(*)
           super
           @stream = @response.stream
         end
@@ -51,80 +143,10 @@ module HTTPX
         end
       end
 
-      class StreamResponse
-        def initialize(request, session)
-          @request = request
-          @session = session
-          @options = @request.options
-        end
-
-        def each(&block)
-          return enum_for(__method__) unless block_given?
-
-          raise Error, "response already streamed" if @response
-
-          @request.stream = self
-
-          begin
-            @on_chunk = block
-
-            response.raise_for_status
-            response.close
-          ensure
-            @on_chunk = nil
-          end
-        end
-
-        def each_line
-          return enum_for(__method__) unless block_given?
-
-          line = +""
-
-          each do |chunk|
-            line << chunk
-
-            while (idx = line.index("\n"))
-              yield line.byteslice(0..idx - 1)
-
-              line = line.byteslice(idx + 1..-1)
-            end
-          end
-        end
-
-        # This is a ghost method. It's to be used ONLY internally, when processing streams
-        def on_chunk(chunk)
-          raise NoMethodError unless @on_chunk
-
-          @on_chunk.call(chunk)
-        end
-
-        # :nocov:
-        def inspect
-          "#<StreamResponse:#{object_id}>"
-        end
-        # :nocov:
-
-        def to_s
-          response.to_s
-        end
-
-        private
-
-        def response
-          @response ||= @session.__send__(:send_requests, @request, @options).first
-        end
-
-        def respond_to_missing?(*args)
-          @options.response_class.respond_to?(*args) || super
-        end
-
-        def method_missing(meth, *args, &block)
-          if @options.response_class.public_method_defined?(meth)
-            response.__send__(meth, *args, &block)
-          else
-            super
-          end
-        end
+      def self.const_missing(const_name)
+        super unless const_name == :StreamResponse
+        warn "DEPRECATION WARNING: the class #{self}::StreamResponse is deprecated. Use HTTPX::StreamResponse instead."
+        HTTPX::StreamResponse
       end
     end
     register_plugin :stream, Stream

data/lib/httpx/plugins/upgrade.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin helps negotiating a new protocol from an HTTP/1.1 connection, via the
+    # Upgrade header.
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Upgrade
+    #
+    module Upgrade
+      class << self
+        def configure(klass)
+          klass.plugin(:"upgrade/h2")
+        end
+
+        def extra_options(options)
+          upgrade_handlers = Module.new do
+            extend Registry
+          end
+
+          Class.new(options.class) do
+            def_option(:upgrade_handlers, <<-OUT)
+              raise Error, ":upgrade_handlers must be a registry" unless value.respond_to?(:registry)
+
+              value
+            OUT
+          end.new(options).merge(upgrade_handlers: upgrade_handlers)
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, connections, options)
+          response = super
+
+          if response
+            return response unless response.respond_to?(:headers) && response.headers.key?("upgrade")
+
+            upgrade_protocol = response.headers["upgrade"].split(/ *, */).first
+
+            return response unless upgrade_protocol && options.upgrade_handlers.registry.key?(upgrade_protocol)
+
+            protocol_handler = options.upgrade_handlers.registry(upgrade_protocol)
+
+            return response unless protocol_handler
+
+            log { "upgrading to #{upgrade_protocol}..." }
+            connection = find_connection(request, connections, options)
+            connections << connection unless connections.include?(connection)
+
+            # do not upgrade already upgraded connections
+            return if connection.upgrade_protocol == upgrade_protocol
+
+            protocol_handler.call(connection, request, response)
+
+            # keep in the loop if the server is switching, unless
+            # the connection has been hijacked, in which case you want
+            # to terminante immediately
+            return if response.status == 101 && !connection.hijacked
+          end
+
+          response
+        end
+
+        def close(*args)
+          return super if args.empty?
+
+          connections, = args
+
+          pool.close(connections.reject(&:hijacked))
+        end
+      end
+
+      module ConnectionMethods
+        attr_reader :upgrade_protocol, :hijacked
+
+        def hijack_io
+          @hijacked = true
+        end
+      end
+    end
+    register_plugin(:upgrade, Upgrade)
+  end
+end

data/lib/httpx/plugins/upgrade/h2.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for upgrading an HTTP/1.1 connection to HTTP/2
+    # via an Upgrade: h2 response declaration
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Upgrade#h2
+    #
+    module H2
+      class << self
+        def configure(klass)
+          klass.default_options.upgrade_handlers.register "h2", self
+        end
+
+        def call(connection, _request, _response)
+          connection.upgrade_to_h2
+        end
+      end
+
+      module ConnectionMethods
+        using URIExtensions
+
+        def upgrade_to_h2
+          prev_parser = @parser
+
+          if prev_parser
+            prev_parser.reset
+            @inflight -= prev_parser.requests.size
+          end
+
+          @parser = Connection::HTTP2.new(@write_buffer, @options)
+          set_parser_callbacks(@parser)
+          @upgrade_protocol = :h2
+
+          # what's happening here:
+          # a deviation from the state machine is done to perform the actions when a
+          # connection is closed, without transitioning, so the connection is kept in the pool.
+          # the state is reset to initial, so that the socket reconnect works out of the box,
+          # while the parser is already here.
+          purge_after_closed
+          transition(:idle)
+
+          prev_parser.requests.each do |req|
+            req.transition(:idle)
+            send(req)
+          end
+        end
+      end
+    end
+    register_plugin(:"upgrade/h2", H2)
+  end
+end

data/lib/httpx/pool.rb

@@ -64,11 +64,6 @@ module HTTPX
       connection.on(:open) do
         @connected_connections += 1
       end
-      connection.on(:unreachable) do
-        resolver = find_resolver_for(connection)
-        resolver.uncache(connection) if resolver
-        resolve_connection(connection)
-      end
     end
 
     # opens a connection to the IP reachable through +uri+.
@@ -85,6 +80,20 @@ module HTTPX
 
     def resolve_connection(connection)
       @connections << connection unless @connections.include?(connection)
+
+      if connection.addresses || connection.state == :open
+        #
+        # there are two cases in which we want to activate initialization of
+        # connection immediately:
+        #
+        # 1. when the connection already has addresses, i.e. it doesn't need to
+        #    resolve a name (not the same as name being an IP, yet)
+        # 2. when the connection is initialized with an external already open IO.
+        #
+        on_resolver_connection(connection)
+        return
+      end
+
       resolver = find_resolver_for(connection)
       resolver << connection
       return if resolver.empty?
@@ -135,7 +144,6 @@ module HTTPX
       connection.on(:close) do
         unregister_connection(connection)
       end
-      return if connection.state == :open
     end
 
     def unregister_connection(connection)

data/lib/httpx/registry.rb

@@ -62,13 +62,7 @@ module HTTPX
         handler = @registry.fetch(tag)
         raise(Error, "#{tag} is not registered in #{self}") unless handler
 
-        case handler
-        when Symbol, String
-          obj = const_get(handler)
-          @registry[tag] = obj
-        else
-          handler
-        end
+        handler
       end
 
       # @param [Object] tag the identifier for the handler in the registry

data/lib/httpx/request.rb

@@ -35,14 +35,22 @@ module HTTPX
 
     attr_reader :verb, :uri, :headers, :body, :state, :options, :response
 
+    # Exception raised during enumerable body writes
+    attr_reader :drain_error
+
     def_delegator :@body, :empty?
 
     def_delegator :@body, :chunk!
 
     def initialize(verb, uri, options = {})
       @verb    = verb.to_s.downcase.to_sym
-      @uri     = Utils.uri(uri)
       @options = Options.new(options)
+      @uri     = Utils.uri(uri)
+      if @uri.relative?
+        raise(Error, "invalid URI: #{@uri}") unless @options.origin
+
+        @uri = @options.origin.merge(@uri)
+      end
 
       raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
 
@@ -54,6 +62,14 @@ module HTTPX
       @state = :idle
     end
 
+    def trailers?
+      defined?(@trailers)
+    end
+
+    def trailers
+      @trailers ||= @options.headers_class.new
+    end
+
     def interests
       return :r if @state == :done || @state == :expect
 
@@ -124,6 +140,9 @@ module HTTPX
       chunk.dup
     rescue StopIteration
       nil
+    rescue StandardError => e
+      @drain_error = e
+      nil
     end
 
     # :nocov:
@@ -200,7 +219,9 @@ module HTTPX
       end
 
       def unbounded_body?
-        chunked? || @body.bytesize == Float::INFINITY
+        return @unbounded_body if defined?(@unbounded_body)
+
+        @unbounded_body = (chunked? || @body.bytesize == Float::INFINITY)
       end
 
       def chunked?
@@ -217,6 +238,16 @@ module HTTPX
         "#{unbounded_body? ? "stream" : "@bytesize=#{bytesize}"}>"
       end
       # :nocov:
+
+      def respond_to_missing?(meth, *args)
+        @body.respond_to?(meth, *args) || super
+      end
+
+      def method_missing(meth, *args, &block)
+        return super unless @body.respond_to?(meth)
+
+        @body.__send__(meth, *args, &block)
+      end
     end
 
     def transition(nextstate)
@@ -243,11 +274,13 @@ module HTTPX
             nextstate = :expect
           end
         end
+      when :trailers
+        return unless @state == :body
       when :done
         return if @state == :expect
       end
       @state = nextstate
-      emit(@state)
+      emit(@state, self)
       nil
     end