httpx 0.12.0 → 0.13.0

data/lib/httpx/options.rb

@@ -6,11 +6,6 @@ module HTTPX
     MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
 
     class << self
-      def inherited(klass)
-        super
-        klass.instance_variable_set(:@defined_options, @defined_options.dup)
-      end
-
       def new(options = {})
         # let enhanced options go through
         return options if self == Options && options.class > self
@@ -19,13 +14,7 @@ module HTTPX
         super
       end
 
-      def defined_options
-        @defined_options ||= []
-      end
-
       def def_option(name, &interpreter)
-        defined_options << name.to_sym
-
         attr_reader name
 
         if interpreter
@@ -34,16 +23,8 @@ module HTTPX
 
             instance_variable_set(:"@#{name}", instance_exec(value, &interpreter))
           end
-
-          define_method(:"with_#{name}") do |value|
-            merge(name => instance_exec(value, &interpreter))
-          end
         else
           attr_writer name
-
-          define_method(:"with_#{name}") do |value|
-            merge(name => value)
-          end
         end
 
         protected :"#{name}="
@@ -69,6 +50,7 @@ module HTTPX
         :connection_class => Class.new(Connection),
         :transport => nil,
         :transport_options => nil,
+        :addresses => nil,
         :persistent => false,
         :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
         :resolver_options => { cache: true },
@@ -121,6 +103,10 @@ module HTTPX
       transport
     end
 
+    def_option(:addresses) do |addrs|
+      Array(addrs)
+    end
+
     %w[
       params form json body ssl http2_settings
       request_class response_class headers_class request_body_class response_body_class connection_class
@@ -153,6 +139,8 @@ module HTTPX
 
       h1 = to_hash
 
+      return self if h1 == h2
+
       merged = h1.merge(h2) do |k, v1, v2|
         case k
         when :headers, :ssl, :http2_settings, :timeout
@@ -166,10 +154,10 @@ module HTTPX
     end
 
     def to_hash
-      hash_pairs = self.class
-                       .defined_options
-                       .flat_map { |opt_name| [opt_name, send(opt_name)] }
-      Hash[*hash_pairs]
+      hash_pairs = instance_variables.map do |ivar|
+        [ivar[1..-1].to_sym, instance_variable_get(ivar)]
+      end
+      Hash[hash_pairs]
     end
 
     def initialize_dup(other)

data/lib/httpx/plugins/compression.rb

@@ -13,15 +13,17 @@ module HTTPX
     # https://gitlab.com/honeyryderchuck/httpx/wikis/Compression
     #
     module Compression
-      extend Registry
-
       class << self
-        def load_dependencies(klass)
+        def configure(klass)
           klass.plugin(:"compression/gzip")
           klass.plugin(:"compression/deflate")
         end
 
         def extra_options(options)
+          encodings = Module.new do
+            extend Registry
+          end
+
           Class.new(options.class) do
             def_option(:compression_threshold_size) do |bytes|
               bytes = Integer(bytes)
@@ -29,7 +31,13 @@ module HTTPX
 
               bytes
             end
-          end.new(options).merge(headers: { "accept-encoding" => Compression.registry.keys })
+
+            def_option(:encodings) do |encs|
+              raise Error, ":encodings must be a registry" unless encs.respond_to?(:registry)
+
+              encs
+            end
+          end.new(options).merge(encodings: encodings)
         end
       end
 
@@ -37,7 +45,11 @@ module HTTPX
         def initialize(*)
           super
           # forego compression in the Range cases
-          @headers.delete("accept-encoding") if @headers.key?("range")
+          if @headers.key?("range")
+            @headers.delete("accept-encoding")
+          else
+            @headers["accept-encoding"] ||= @options.encodings.registry.keys
+          end
         end
       end
 
@@ -52,7 +64,7 @@ module HTTPX
           @headers.get("content-encoding").each do |encoding|
             next if encoding == "identity"
 
-            @body = Encoder.new(@body, Compression.registry(encoding).deflater)
+            @body = Encoder.new(@body, options.encodings.registry(encoding).deflater)
           end
           @headers["content-length"] = @body.bytesize unless chunked?
         end
@@ -61,7 +73,7 @@ module HTTPX
       module ResponseBodyMethods
         attr_reader :encodings
 
-        def initialize(*, **)
+        def initialize(*)
           @encodings = []
 
           super
@@ -80,7 +92,7 @@ module HTTPX
           @_inflaters = @headers.get("content-encoding").map do |encoding|
             next if encoding == "identity"
 
-            inflater = Compression.registry(encoding).inflater(compressed_length)
+            inflater = @options.encodings.registry(encoding).inflater(compressed_length)
             # do not uncompress if there is no decoder available. In fact, we can't reliably
             # continue decompressing beyond that, so ignore.
             break unless inflater

data/lib/httpx/plugins/compression/brotli.rb

@@ -4,13 +4,15 @@ module HTTPX
   module Plugins
     module Compression
       module Brotli
-        def self.load_dependencies(klass)
-          klass.plugin(:compression)
-          require "brotli"
-        end
+        class << self
+          def load_dependencies(klass)
+            klass.plugin(:compression)
+            require "brotli"
+          end
 
-        def self.configure(*)
-          Compression.register "br", self
+          def configure(klass)
+            klass.default_options.encodings.register "br", self
+          end
         end
 
         module Deflater

data/lib/httpx/plugins/compression/deflate.rb

@@ -10,8 +10,8 @@ module HTTPX
           klass.plugin(:"compression/gzip")
         end
 
-        def self.configure(*)
-          Compression.register "deflate", self
+        def self.configure(klass)
+          klass.default_options.encodings.register "deflate", self
         end
 
         module Deflater

data/lib/httpx/plugins/compression/gzip.rb

@@ -10,8 +10,8 @@ module HTTPX
           require "zlib"
         end
 
-        def self.configure(*)
-          Compression.register "gzip", self
+        def self.configure(klass)
+          klass.default_options.encodings.register "gzip", self
         end
 
         class Deflater

data/lib/httpx/plugins/digest_authentication.rb

@@ -29,7 +29,7 @@ module HTTPX
 
       module InstanceMethods
         def digest_authentication(user, password)
-          branch(default_options.with_digest(Digest.new(user, password)))
+          with(digest: Digest.new(user, password))
         end
 
         alias_method :digest_auth, :digest_authentication

data/lib/httpx/plugins/follow_redirects.rb

@@ -32,7 +32,7 @@ module HTTPX
 
       module InstanceMethods
         def max_redirects(n)
-          branch(default_options.with_max_redirects(n.to_i))
+          with(max_redirects: n.to_i)
         end
 
         private

data/lib/httpx/plugins/h2c.rb

@@ -6,68 +6,53 @@ module HTTPX
     # This plugin adds support for upgrading a plaintext HTTP/1.1 connection to HTTP/2
     # (https://tools.ietf.org/html/rfc7540#section-3.2)
     #
-    # https://gitlab.com/honeyryderchuck/httpx/wikis/Follow-Redirects
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Upgrade#h2c
     #
     module H2C
-      def self.load_dependencies(*)
-        require "base64"
+      VALID_H2C_VERBS = %i[get options head].freeze
+
+      class << self
+        def load_dependencies(*)
+          require "base64"
+        end
+
+        def configure(klass)
+          klass.plugin(:upgrade)
+          klass.default_options.upgrade_handlers.register "h2c", self
+        end
+
+        def call(connection, request, response)
+          connection.upgrade_to_h2c(request, response)
+        end
       end
 
       module InstanceMethods
-        def request(*args, **options)
-          h2c_options = options.merge(fallback_protocol: "h2c")
+        def send_requests(*requests, options)
+          upgrade_request, *remainder = requests
+
+          return super unless VALID_H2C_VERBS.include?(upgrade_request.verb) && upgrade_request.scheme == "http"
 
-          requests = build_requests(*args, h2c_options)
+          connection = pool.find_connection(upgrade_request.uri, @options.merge(options))
 
-          upgrade_request = requests.first
-          return super unless valid_h2c_upgrade_request?(upgrade_request)
+          return super if connection && connection.upgrade_protocol == :h2c
 
+          # build upgrade request
           upgrade_request.headers.add("connection", "upgrade")
           upgrade_request.headers.add("connection", "http2-settings")
           upgrade_request.headers["upgrade"] = "h2c"
           upgrade_request.headers["http2-settings"] = HTTP2Next::Client.settings_header(upgrade_request.options.http2_settings)
-          wrap { send_requests(*upgrade_request, h2c_options).first }
 
-          responses = send_requests(*requests, h2c_options)
-
-          responses.size == 1 ? responses.first : responses
-        end
-
-        private
-
-        def fetch_response(request, connections, options)
-          response = super
-          if response && valid_h2c_upgrade?(request, response, options)
-            log { "upgrading to h2c..." }
-            connection = find_connection(request, connections, options)
-            connections << connection unless connections.include?(connection)
-            connection.upgrade(request, response)
-          end
-          response
-        end
-
-        VALID_H2C_METHODS = %i[get options head].freeze
-        private_constant :VALID_H2C_METHODS
-
-        def valid_h2c_upgrade_request?(request)
-          VALID_H2C_METHODS.include?(request.verb) &&
-            request.scheme == "http"
-        end
-
-        def valid_h2c_upgrade?(request, response, options)
-          options.fallback_protocol == "h2c" &&
-            request.headers.get("connection").include?("upgrade") &&
-            request.headers.get("upgrade").include?("h2c") &&
-            response.status == 101
+          super(upgrade_request, *remainder, options.merge(max_concurrent_requests: 1))
         end
       end
 
       class H2CParser < Connection::HTTP2
         def upgrade(request, response)
-          @connection.send_connection_preface
           # skip checks, it is assumed that this is the first
           # request in the connection
           stream = @connection.upgrade
+
+          # on_settings
           handle_stream(stream, request)
           @streams[request] = stream
 
@@ -81,29 +66,29 @@ module HTTPX
       module ConnectionMethods
         using URIExtensions
 
-        def match?(uri, options)
-          return super unless uri.scheme == "http" && @options.fallback_protocol == "h2c"
-
-          super && options.fallback_protocol == "h2c"
-        end
-
-        def coalescable?(connection)
-          return super unless @options.fallback_protocol == "h2c" && @origin.scheme == "http"
+        def upgrade_to_h2c(request, response)
+          prev_parser = @parser
 
-          @origin == connection.origin && connection.options.fallback_protocol == "h2c"
-        end
+          if prev_parser
+            prev_parser.reset
+            @inflight -= prev_parser.requests.size
+          end
 
-        def upgrade(request, response)
-          @parser.reset if @parser
-          @parser = H2CParser.new(@write_buffer, @options)
+          parser_options = @options.merge(max_concurrent_requests: request.options.max_concurrent_requests)
+          @parser = H2CParser.new(@write_buffer, parser_options)
           set_parser_callbacks(@parser)
+          @inflight += 1
           @parser.upgrade(request, response)
-        end
+          @upgrade_protocol = :h2c
 
-        def build_parser(*)
-          return super unless @origin.scheme == "http"
+          if request.options.max_concurrent_requests != @options.max_concurrent_requests
+            @options = @options.merge(max_concurrent_requests: nil)
+          end
 
-          super("http/1.1")
+          prev_parser.requests.each do |req|
+            req.transition(:idle)
+            send(req)
+          end
         end
       end
     end

data/lib/httpx/plugins/internal_telemetry.rb

@@ -71,7 +71,7 @@ module HTTPX
         def transition(nextstate)
           state = @state
           super
-          meter_elapsed_time("Request[#{@verb} #{@uri}: #{state}] -> #{nextstate}") if nextstate == @state
+          meter_elapsed_time("Request##{object_id}[#{@verb} #{@uri}: #{state}] -> #{nextstate}") if nextstate == @state
         end
       end
 

data/lib/httpx/plugins/retries.rb

@@ -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

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