httpx 0.11.2 → 0.13.2

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,18 +10,15 @@ 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
           module_function
 
           def deflate(raw, buffer, chunk_size:)
-            deflater = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
-                                         Zlib::MAX_WBITS,
-                                         Zlib::MAX_MEM_LEVEL,
-                                         Zlib::HUFFMAN_ONLY)
+            deflater = Zlib::Deflate.new
             while (chunk = raw.read(chunk_size))
               compressed = deflater.deflate(chunk)
               buffer << compressed
@@ -31,7 +28,7 @@ module HTTPX
             buffer << last
             yield last if block_given?
           ensure
-            deflater.close
+            deflater.close if deflater
           end
         end
 

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # The InternalTelemetry plugin is for internal use only. It is therefore undocumented, and
+    # its use is disencouraged, as API compatiblity will **not be guaranteed**.
+    #
+    # The gist of it is: when debug_level of logger is enabled to 3 or greater, considered internal-only
+    # supported log levels, it'll be loaded by default.
+    #
+    # Against a specific point of time, which will be by default the session initialization, but can be set
+    # by the end user in $http_init_time, different diff metrics can be shown. The "point of time" is calculated
+    # using the monotonic clock.
+    module InternalTelemetry
+      module TrackTimeMethods
+        private
+
+        def elapsed_time
+          yield
+        ensure
+          meter_elapsed_time("#{self.class.superclass}##{caller_locations(1, 1)[0].label}")
+        end
+
+        def meter_elapsed_time(label)
+          $http_init_time ||= Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+          prev_time = $http_init_time
+          after_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+          # $http_init_time = after_time
+          elapsed = after_time - prev_time
+          warn(+"\e[31m" << "[ELAPSED TIME]: #{label}: #{elapsed} (ms)" << "\e[0m")
+        end
+      end
+
+      module InstanceMethods
+        def self.included(klass)
+          klass.prepend TrackTimeMethods
+          super
+        end
+
+        def initialize(*)
+          meter_elapsed_time("Session: initializing...")
+          super
+          meter_elapsed_time("Session: initialized!!!")
+        end
+
+        private
+
+        def build_requests(*)
+          elapsed_time { super }
+        end
+
+        def fetch_response(*)
+          response = super
+          meter_elapsed_time("Session -> response") if response
+          response
+        end
+
+        def close(*)
+          super
+          meter_elapsed_time("Session -> close")
+        end
+      end
+
+      module RequestMethods
+        def self.included(klass)
+          klass.prepend TrackTimeMethods
+          super
+        end
+
+        def transition(nextstate)
+          state = @state
+          super
+          meter_elapsed_time("Request##{object_id}[#{@verb} #{@uri}: #{state}] -> #{nextstate}") if nextstate == @state
+        end
+      end
+
+      module ConnectionMethods
+        def self.included(klass)
+          klass.prepend TrackTimeMethods
+          super
+        end
+
+        def transition(nextstate)
+          state = @state
+          super
+          meter_elapsed_time("Connection[#{@origin}]: #{state} -> #{nextstate}") if nextstate == @state
+        end
+      end
+    end
+    register_plugin :internal_telemetry, InternalTelemetry
+  end
+end

data/lib/httpx/plugins/multipart.rb

@@ -23,6 +23,7 @@ module HTTPX
         end
 
         def load_dependencies(*)
+          # :nocov:
           begin
             unless defined?(HTTP::FormData)
               # in order not to break legacy code, we'll keep loading http/form_data for them.
@@ -33,6 +34,7 @@ module HTTPX
             end
           rescue LoadError
           end
+          # :nocov:
           require "httpx/plugins/multipart/encoder"
           require "httpx/plugins/multipart/part"
           require "httpx/plugins/multipart/mime_type_detector"

data/lib/httpx/plugins/multipart/encoder.rb

@@ -29,18 +29,13 @@ module HTTPX::Plugins
 
       def rewind
         form = @form.each_with_object([]) do |(key, val), aux|
-          v = case val
-              when File
-                val = val.reopen(val.path, File::RDONLY) if val.closed?
-                val.rewind
-                val
-              else
-                v
-          end
-          aux << [key, v]
+          val = val.reopen(val.path, File::RDONLY) if val.is_a?(File) && val.closed?
+          val.rewind if val.respond_to?(:rewind)
+          aux << [key, val]
         end
         @form = form
         @parts = to_parts(form)
+        @part_index = 0
       end
 
       private

data/lib/httpx/plugins/proxy.rb

@@ -242,7 +242,7 @@ module HTTPX
     register_plugin :proxy, Proxy
   end
 
-  class ProxySSL < SSL
+  class ProxySSL < IO.registry["ssl"]
     def initialize(tcp, request_uri, options)
       @io = tcp.to_io
       super(request_uri, tcp.addresses, options)

data/lib/httpx/plugins/proxy/http.rb

@@ -81,7 +81,7 @@ module HTTPX
             request.uri.to_s
           end
 
-          def set_request_headers(request)
+          def set_protocol_headers(request)
             super
             proxy_params = @options.proxy
             request.headers["proxy-authorization"] = "Basic #{proxy_params.token_authentication}" if proxy_params.authenticated?