httpx 0.11.0 → 0.13.0

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/cookies/set_cookie_parser.rb

@@ -107,7 +107,7 @@ module HTTPX
               case aname
               when "expires"
                 # RFC 6265 5.2.1
-                (avalue &&= Time.httpdate(avalue)) || next
+                (avalue &&= Time.parse(avalue)) || next
               when "max-age"
                 # RFC 6265 5.2.2
                 next unless /\A-?\d+\z/.match?(avalue)

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?

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

@@ -16,6 +16,14 @@ module HTTPX
         Error = Socks4Error
 
         module ConnectionMethods
+          def interests
+            if @state == :connecting
+              return @write_buffer.empty? ? :r : :w
+            end
+
+            super
+          end
+
           private
 
           def transition(nextstate)

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

@@ -35,6 +35,14 @@ module HTTPX
             super || @state == :authenticating || @state == :negotiating
           end
 
+          def interests
+            if @state == :connecting || @state == :authenticating || @state == :negotiating
+              return @write_buffer.empty? ? :r : :w
+            end
+
+            super
+          end
+
           private
 
           def transition(nextstate)

data/lib/httpx/plugins/push_promise.rb

@@ -43,7 +43,7 @@ module HTTPX
         end
 
         def __on_promise_request(parser, stream, h)
-          log(level: 1) do
+          log(level: 1, color: :yellow) do
             # :nocov:
             h.map { |k, v| "#{stream.id}: -> PROMISE HEADER: #{k}: #{v}" }.join("\n")
             # :nocov:
@@ -57,6 +57,8 @@ module HTTPX
             request.merge_headers(headers)
             promise_headers[stream] = request
             parser.pending.delete(request)
+            parser.streams[request] = stream
+            request.transition(:done)
           else
             stream.refuse
           end
@@ -67,7 +69,6 @@ module HTTPX
           return unless request
 
           parser.__send__(:on_stream_headers, stream, request, h)
-          request.transition(:done)
           response = request.response
           response.mark_as_pushed!
           stream.on(:data, &parser.method(:on_stream_data).curry(3)[stream, request])