httpx 0.11.0 → 0.13.0

data/lib/httpx/plugins/retries.rb

@@ -17,7 +17,7 @@ module HTTPX
                           Errno::ECONNRESET,
                           Errno::ECONNABORTED,
                           Errno::EPIPE,
-                          (OpenSSL::SSL::SSLError if defined?(OpenSSL)),
+                          (TLSError if defined?(TLSError)),
                           TimeoutError,
                           Parser::Error,
                           Errno::EINVAL,
@@ -55,7 +55,7 @@ module HTTPX
 
       module InstanceMethods
         def max_retries(n)
-          branch(default_options.with_max_retries(n.to_i))
+          with(max_retries: n.to_i)
         end
 
         private

data/lib/httpx/plugins/stream.rb

@@ -5,6 +5,8 @@ module HTTPX
     #
     # This plugin adds support for stream response (text/event-stream).
     #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Stream
+    #
     module Stream
       module InstanceMethods
         private
@@ -31,7 +33,7 @@ module HTTPX
       end
 
       module ResponseBodyMethods
-        def initialize(*, **)
+        def initialize(*)
           super
           @stream = @response.stream
         end
@@ -119,11 +121,9 @@ module HTTPX
         end
 
         def method_missing(meth, *args, &block)
-          if @options.response_class.public_method_defined?(meth)
-            response.__send__(meth, *args, &block)
-          else
-            super
-          end
+          return super unless @options.response_class.public_method_defined?(meth)
+
+          response.__send__(meth, *args, &block)
         end
       end
     end

data/lib/httpx/plugins/upgrade.rb

@@ -0,0 +1,83 @@
+# 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) do |encs|
+              raise Error, ":upgrade_handlers must be a registry" unless encs.respond_to?(:registry)
+
+              encs
+            end
+          end.new(options).merge(upgrade_handlers: upgrade_handlers)
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, connections, options)
+          response = super
+
+          if response && 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

@@ -217,6 +217,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)
@@ -247,7 +257,7 @@ module HTTPX
         return if @state == :expect
       end
       @state = nextstate
-      emit(@state)
+      emit(@state, self)
       nil
     end
 

data/lib/httpx/resolver/https.rb

@@ -55,20 +55,12 @@ module HTTPX
       early_resolve(connection) || resolve(connection)
     end
 
-    def timeout
-      @connections.map(&:timeout).min
-    end
-
     def closed?
-      return true unless @resolver_connection
-
-      resolver_connection.closed?
+      true
     end
 
-    def interests
-      return if @queries.empty?
-
-      resolver_connection.__send__(__method__)
+    def empty?
+      true
     end
 
     private

data/lib/httpx/response.rb

@@ -27,8 +27,7 @@ module HTTPX
       @version = version
       @status = Integer(status)
       @headers = @options.headers_class.new(headers)
-      @body = @options.response_body_class.new(self, threshold_size: @options.body_threshold_size,
-                                                     window_size: @options.window_size)
+      @body = @options.response_body_class.new(self, @options)
     end
 
     def merge_headers(h)
@@ -83,11 +82,12 @@ module HTTPX
     end
 
     class Body
-      def initialize(response, threshold_size:, window_size: 1 << 14)
+      def initialize(response, options)
         @response = response
         @headers = response.headers
-        @threshold_size = threshold_size
-        @window_size = window_size
+        @options = options
+        @threshold_size = options.body_threshold_size
+        @window_size = options.window_size
         @encoding = response.content_type.charset || Encoding::BINARY
         @length = 0
         @buffer = nil
@@ -268,8 +268,15 @@ module HTTPX
       @error.message
     end
 
-    def to_s
-      @error.backtrace.join("\n")
+    if Exception.method_defined?(:full_message)
+      def to_s
+        @error.full_message
+      end
+    else
+      def to_s
+        "#{@error.message} (#{@error.class})\n" \
+        "#{@error.backtrace.join("\n") if @error.backtrace}"
+      end
     end
 
     def raise_for_status

data/lib/httpx/selector.rb

@@ -69,6 +69,11 @@ class HTTPX::Selector
 
         if @selectables.empty?
           @selectables = selectables
+
+          # do not run event loop if there's nothing to wait on.
+          # this might happen if connect failed and connection was unregistered.
+          return if (!r || r.empty?) && (!w || w.empty?)
+
           break
         else
           @selectables = [*selectables, @selectables]

data/lib/httpx/session.rb

@@ -199,7 +199,18 @@ module HTTPX
           responses << response
           requests.shift
 
-          break if requests.empty? || pool.empty?
+          break if requests.empty?
+
+          next unless pool.empty?
+
+          # in some cases, the pool of connections might have been drained because there was some
+          # handshake error, and the error responses have already been emitted, but there was no
+          # opportunity to traverse the requests, hence we're returning only a fraction of the errors
+          # we were supposed to. This effectively fetches the existing responses and return them.
+          while (request = requests.shift)
+            responses << fetch_response(request, connections, request_options)
+          end
+          break
         end
         responses
       ensure
@@ -269,7 +280,19 @@ module HTTPX
       end
       # :nocov:
     end
+  end
+
+  unless ENV.grep(/https?_proxy$/i).empty?
+    proxy_session = plugin(:proxy)
+    ::HTTPX.send(:remove_const, :Session)
+    ::HTTPX.send(:const_set, :Session, proxy_session.class)
+  end
 
-    plugin(:proxy) unless ENV.grep(/https?_proxy$/i).empty?
+  # :nocov:
+  if Session.default_options.debug_level > 2
+    proxy_session = plugin(:internal_telemetry)
+    ::HTTPX.send(:remove_const, :Session)
+    ::HTTPX.send(:const_set, :Session, proxy_session.class)
   end
+  # :nocov:
 end

data/lib/httpx/transcoder/body.rb

@@ -44,11 +44,9 @@ module HTTPX::Transcoder
       end
 
       def method_missing(meth, *args, &block)
-        if @raw.respond_to?(meth)
-          @raw.__send__(meth, *args, &block)
-        else
-          super
-        end
+        return super unless @raw.respond_to?(meth)
+
+        @raw.__send__(meth, *args, &block)
       end
     end
 

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.11.0"
+  VERSION = "0.13.0"
 end

data/sig/chainable.rbs

@@ -18,7 +18,8 @@ module HTTPX
               | (:cookies) -> Plugins::sessionCookies
               | (:expect) -> Session
               | (:follow_redirects) -> Plugins::sessionFollowRedirects
-              | (:h2c) -> Plugins::sessionH2C
+              | (:upgrade) -> Session
+              | (:h2c) -> Session
               | (:multipart) -> Session
               | (:persistent) -> Plugins::sessionPersistent
               | (:proxy) -> Plugins::sessionProxy

data/sig/connection/http1.rbs

@@ -4,6 +4,7 @@ module HTTPX
     include Loggable
 
     attr_reader pending: Array[Request]
+    attr_reader requests: Array[Request]
 
     @options: Options
     @max_concurrent_requests: Integer
@@ -31,7 +32,7 @@ module HTTPX
 
     def on_headers: (Hash[String, Array[String]] headers) -> void
 
-    def on_trailers: (Array[String, String] headers) -> void
+    def on_trailers: (Hash[String, Array[String]] headers) -> void
 
     def on_data: (string chunk) -> void
 
@@ -51,7 +52,7 @@ module HTTPX
 
     def disable_pipelining: () -> void
 
-    def set_request_headers: (Request) -> void
+    def set_protocol_headers: (Request) -> void
 
     def headline_uri: (Request) -> String