httpx 0.6.7 → 0.9.0

data/lib/httpx/plugins/digest_authentication.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 module HTTPX
   module Plugins
     #

data/lib/httpx/plugins/expect.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin makes all HTTP/1.1 requests with a body send the "Expect: 100-continue".
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Expect#expect
+    #
+    module Expect
+      EXPECT_TIMEOUT = 2
+
+      def self.extra_options(options)
+        Class.new(options.class) do
+          def_option(:expect_timeout) do |seconds|
+            seconds = Integer(seconds)
+            raise Error, ":expect_timeout must be positive" unless seconds.positive?
+
+            seconds
+          end
+
+          def_option(:expect_threshold_size) do |bytes|
+            bytes = Integer(bytes)
+            raise Error, ":expect_threshold_size must be positive" unless bytes.positive?
+
+            bytes
+          end
+        end.new(options).merge(expect_timeout: EXPECT_TIMEOUT)
+      end
+
+      module RequestBodyMethods
+        def initialize(*, options)
+          super
+          return if @body.nil?
+
+          if (threshold = options.expect_threshold_size)
+            unless unbounded_body?
+              return if @body.bytesize < threshold
+            end
+          end
+
+          @headers["expect"] = "100-continue"
+        end
+      end
+
+      module ConnectionMethods
+        def send(request)
+          request.once(:expects) do
+            @timers.after(@options.expect_timeout) do
+              if request.state == :expects && !request.expects?
+                request.headers.delete("expect")
+                handle(request)
+              end
+            end
+          end
+          super
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, connections, options)
+          response = @responses.delete(request)
+          return unless response
+
+          if response.status == 417 && request.headers.key?("expect")
+            request.headers.delete("expect")
+            request.transition(:idle)
+            connection = find_connection(request, connections, options)
+            connection.send(request)
+            return
+          end
+
+          response
+        end
+      end
+    end
+    register_plugin :expect, Expect
+  end
+end

data/lib/httpx/plugins/follow_redirects.rb

@@ -21,7 +21,7 @@ module HTTPX
         Class.new(options.class) do
           def_option(:max_redirects) do |num|
             num = Integer(num)
-            raise Error, ":max_redirects must be positive" unless num.positive?
+            raise Error, ":max_redirects must be positive" if num.negative?
 
             num
           end
@@ -61,7 +61,6 @@ module HTTPX
 
           connection = find_connection(retry_request, connections, options)
           connection.send(retry_request)
-          set_request_timeout(connection, retry_request, options)
           nil
         end
 

data/lib/httpx/plugins/h2c.rb

@@ -42,7 +42,6 @@ module HTTPX
             connection = find_connection(request, connections, options)
             connections << connection unless connections.include?(connection)
             connection.upgrade(request, response)
-            set_request_timeout(connection, request, options)
           end
           response
         end

data/lib/httpx/plugins/proxy.rb

@@ -68,17 +68,17 @@ module HTTPX
         def extra_options(options)
           Class.new(options.class) do
             def_option(:proxy) do |pr|
-              Hash[pr]
+              if pr.is_a?(Parameters)
+                pr
+              else
+                Hash[pr]
+              end
             end
           end.new(options)
         end
       end
 
       module InstanceMethods
-        def with_proxy(*args)
-          branch(default_options.with_proxy(*args))
-        end
-
         private
 
         def proxy_uris(uri, options)
@@ -104,7 +104,7 @@ module HTTPX
           connection = pool.find_connection(uri, proxy_options) || build_connection(uri, proxy_options)
           unless connections.nil? || connections.include?(connection)
             connections << connection
-            set_connection_callbacks(connection, options)
+            set_connection_callbacks(connection, connections, options)
           end
           connection
         end
@@ -129,13 +129,12 @@ module HTTPX
             connection = find_connection(request, connections, options)
             connections << connection unless connections.include?(connection)
             connection.send(request)
-            set_request_timeout(connection, request, options)
             return
           end
           response
         end
 
-        def build_altsvc_connection(_, _, _, _, options)
+        def build_altsvc_connection(_, _, _, _, _, options)
           return if options.proxy
 
           super
@@ -180,20 +179,9 @@ module HTTPX
           super || @state == :connecting || @state == :connected
         end
 
-        def to_io
-          return super unless @options.proxy
-
-          case @state
-          when :idle
-            transition(:connecting)
-          when :connected
-            transition(:open)
-          end
-          @io.to_io
-        end
-
         def call
           super
+
           return unless @options.proxy
 
           case @state
@@ -211,11 +199,26 @@ module HTTPX
           emit(:close)
         end
 
+        private
+
+        def connect
+          return super unless @options.proxy
+
+          case @state
+          when :idle
+            transition(:connecting)
+          when :connected
+            transition(:open)
+          end
+        end
+
         def transition(nextstate)
           return super unless @options.proxy
 
           case nextstate
           when :closing
+            # this is a hack so that we can use the super method
+            # and it'll thing that the current state is open
             @state = :open if @state == :connecting
           end
           super

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

@@ -7,6 +7,10 @@ module HTTPX
     module Proxy
       module HTTP
         module ConnectionMethods
+          def connecting?
+            super || @state == :connecting || @state == :connected
+          end
+
           private
 
           def transition(nextstate)
@@ -34,7 +38,6 @@ module HTTPX
               when :idle
                 @parser = ProxyParser.new(@write_buffer, @options)
                 set_parser_callbacks(@parser)
-                @parser.on(:close) { transition(:closing) }
               end
             end
             super
@@ -48,7 +51,7 @@ module HTTPX
             #
             if req.uri.scheme == "https"
               connect_request = ConnectRequest.new(req.uri, @options)
-
+              @inflight += 1
               parser.send(connect_request)
             else
               transition(:connected)
@@ -56,6 +59,7 @@ module HTTPX
           end
 
           def __http_on_connect(_, response)
+            @inflight -= 1
             if response.status == 200
               req = @pending.first
               request_uri = req.uri
@@ -67,6 +71,7 @@ module HTTPX
               while (req = pending.shift)
                 req.emit(:response, response)
               end
+              reset
             end
           end
         end
@@ -91,15 +96,13 @@ module HTTPX
           def headline_uri(request)
             return super unless request.verb == :connect
 
-            uri = request.uri
-            tunnel = "#{uri.hostname}:#{uri.port}"
+            tunnel = request.path
             log { "establishing HTTP proxy tunnel to #{tunnel}" }
             tunnel
           end
 
           def empty?
-            @requests.reject { |r| r.verb == :connect }.empty? ||
-              @requests.all? { |request| !request.response.nil? }
+            @requests.reject { |r| r.verb == :connect }.empty? || @requests.all? { |request| !request.response.nil? }
           end
         end
 

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

@@ -39,7 +39,7 @@ module HTTPX
 
               @parser = nil
             end
-            log(level: 1, label: "SOCKS4: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
+            log(level: 1) { "SOCKS4: #{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
             super
           end
 

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

@@ -31,6 +31,10 @@ module HTTPX
             end
           end
 
+          def connecting?
+            super || @state == :authenticating || @state == :negotiating
+          end
+
           private
 
           def transition(nextstate)
@@ -60,7 +64,7 @@ module HTTPX
 
               @parser = nil
             end
-            log(level: 1, label: "SOCKS5: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
+            log(level: 1) { "SOCKS5: #{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
             super
           end
 

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

@@ -19,10 +19,6 @@ module HTTPX
         end
 
         module InstanceMethods
-          def with_proxy(*args)
-            branch(default_options.with_proxy(*args))
-          end
-
           private
 
           def send_requests(*requests, options)

data/lib/httpx/plugins/push_promise.rb

@@ -43,9 +43,9 @@ module HTTPX
         end
 
         def __on_promise_request(parser, stream, h)
-          log(level: 1, label: "#{stream.id}: ") do
+          log(level: 1) do
             # :nocov:
-            h.map { |k, v| "-> PROMISE HEADER: #{k}: #{v}" }.join("\n")
+            h.map { |k, v| "#{stream.id}: -> PROMISE HEADER: #{k}: #{v}" }.join("\n")
             # :nocov:
           end
           headers = @options.headers_class.new(h)

data/lib/httpx/plugins/retries.rb

@@ -28,10 +28,10 @@ module HTTPX
           # number of seconds after which one can retry the request
           def_option(:retry_after) do |num|
             # return early if callable
-            return num if num.respond_to?(:call)
-
-            num = Integer(num)
-            raise Error, ":retry_after must be positive" unless num.positive?
+            unless num.respond_to?(:call)
+              num = Integer(num)
+              raise Error, ":retry_after must be positive" unless num.positive?
+            end
 
             num
           end
@@ -46,7 +46,7 @@ module HTTPX
           def_option(:retry_change_requests)
 
           def_option(:retry_on) do |callback|
-            raise ":retry_on must be called with the response" unless callback.respond_to?(:call) && callback.method(:call).arity == 1
+            raise ":retry_on must be called with the response" unless callback.respond_to?(:call)
 
             callback
           end
@@ -63,18 +63,38 @@ module HTTPX
         def fetch_response(request, connections, options)
           response = super
 
-          retry_on = options.retry_on
-
-          if response.is_a?(ErrorResponse) &&
+          if response &&
              request.retries.positive? &&
              __repeatable_request?(request, options) &&
-             __retryable_error?(response.error) &&
-             (!retry_on || retry_on.call(response))
+             (
+               # rubocop:disable Style/MultilineTernaryOperator
+               options.retry_on ?
+               options.retry_on.call(response) :
+               (
+                 response.is_a?(ErrorResponse) && __retryable_error?(response.error)
+               )
+               # rubocop:enable Style/MultilineTernaryOperator
+             )
+
             request.retries -= 1
             log { "failed to get response, #{request.retries} tries to go..." }
             request.transition(:idle)
-            connection = find_connection(request, connections, options)
-            __retry_request(connection, request, options)
+
+            retry_after = options.retry_after
+            if retry_after
+              retry_after = retry_after.call(request) if retry_after.respond_to?(:call)
+
+              log { "retrying after #{retry_after} secs..." }
+              pool.after(retry_after) do
+                log { "retrying!!" }
+                connection = find_connection(request, connections, options)
+                connection.send(request)
+              end
+            else
+              connection = find_connection(request, connections, options)
+              connection.send(request)
+            end
+
             return
           end
           response
@@ -87,23 +107,6 @@ module HTTPX
         def __retryable_error?(ex)
           RETRYABLE_ERRORS.any? { |klass| ex.is_a?(klass) }
         end
-
-        def __retry_request(connection, request, options)
-          retry_after = options.retry_after
-          unless retry_after
-            connection.send(request)
-            set_request_timeout(connection, request, options)
-            return
-          end
-
-          retry_after = retry_after.call(request) if retry_after.respond_to?(:call)
-          log { "retrying after #{retry_after} secs..." }
-          pool.after(retry_after) do
-            log { "retrying!!" }
-            connection.send(request)
-            set_request_timeout(connection, request, options)
-          end
-        end
       end
 
       module RequestMethods

data/lib/httpx/pool.rb

@@ -14,7 +14,7 @@ module HTTPX
 
     def initialize
       @resolvers = {}
-      @_resolver_monitors = {}
+      @_resolver_ios = {}
       @timers = Timers::Group.new
       @selector = Selector.new
       @connections = []
@@ -27,12 +27,19 @@ module HTTPX
 
     def next_tick
       catch(:jump_tick) do
-        @selector.select(next_timeout || @timers.wait_interval) do |monitor|
-          monitor.io.call
-          monitor.interests = monitor.io.interests
+        timeout = [next_timeout, @timers.wait_interval].compact.min
+        if timeout && timeout.negative?
+          @timers.fire
+          throw(:jump_tick)
         end
+
+        @selector.select(timeout, &:call)
+
         @timers.fire
       end
+    rescue Interrupt
+      @connections.each(&:reset)
+      raise
     rescue StandardError => e
       @connections.each do |connection|
         connection.emit(:error, e)
@@ -51,6 +58,7 @@ module HTTPX
 
     def init_connection(connection, _options)
       resolve_connection(connection)
+      connection.timers = @timers
       connection.on(:open) do
         @connected_connections += 1
       end
@@ -79,7 +87,7 @@ module HTTPX
       resolver << connection
       return if resolver.empty?
 
-      @_resolver_monitors[resolver] ||= @selector.register(resolver, :w)
+      @_resolver_ios[resolver] ||= @selector.register(resolver)
     end
 
     def on_resolver_connection(connection)
@@ -111,8 +119,7 @@ module HTTPX
       @resolvers.delete(resolver_type)
 
       @selector.deregister(resolver)
-      monitor = @_resolver_monitors.delete(resolver)
-      monitor.close if monitor
+      @_resolver_ios.delete(resolver)
       resolver.close unless resolver.closed?
     end
 
@@ -121,10 +128,8 @@ module HTTPX
         # if open, an IO was passed upstream, therefore
         # consider it connected already.
         @connected_connections += 1
-        @selector.register(connection, :rw)
-      else
-        @selector.register(connection, :w)
       end
+      @selector.register(connection)
       connection.on(:close) do
         unregister_connection(connection)
       end