httpx 0.15.4 → 0.18.0

data/lib/httpx/connection.rb

@@ -69,10 +69,10 @@ module HTTPX
       end
 
       @inflight = 0
-      @keep_alive_timeout = options.timeout[:keep_alive_timeout]
-      @keep_alive_timer = nil
+      @keep_alive_timeout = @options.timeout[:keep_alive_timeout]
+      @total_timeout = @options.timeout[:total_timeout]
 
-      self.addresses = options.addresses if options.addresses
+      self.addresses = @options.addresses if @options.addresses
     end
 
     # this is a semi-private method, to be used by the resolver
@@ -200,11 +200,9 @@ module HTTPX
     end
 
     def close
-      @parser.close if @parser
-      return unless @keep_alive_timer
+      transition(:active) if @state == :inactive
 
-      @keep_alive_timer.cancel
-      remove_instance_variable(:@keep_alive_timer)
+      @parser.close if @parser
     end
 
     def reset
@@ -216,26 +214,40 @@ module HTTPX
     def send(request)
       if @parser && !@write_buffer.full?
         request.headers["alt-used"] = @origin.authority if match_altsvcs?(request.uri)
-        if @keep_alive_timer
+
+        if @response_received_at && @keep_alive_timeout &&
+           Utils.elapsed_time(@response_received_at) > @keep_alive_timeout
           # when pushing a request into an existing connection, we have to check whether there
           # is the possibility that the connection might have extended the keep alive timeout.
           # for such cases, we want to ping for availability before deciding to shovel requests.
-          if @keep_alive_timer.fires_in.negative?
-            @pending << request
-            parser.ping
-            return
-          end
-
-          @keep_alive_timer.pause
+          @pending << request
+          parser.ping
+          transition(:active) if @state == :inactive
+          return
         end
-        @inflight += 1
-        parser.send(request)
+
+        send_request_to_parser(request)
       else
         @pending << request
       end
     end
 
     def timeout
+      if @total_timeout
+        return @total_timeout unless @connected_at
+
+        elapsed_time = @total_timeout - Utils.elapsed_time(@connected_at)
+
+        if elapsed_time.negative?
+          ex = TotalTimeoutError.new(@total_timeout, "Timed out after #{@total_timeout} seconds")
+          ex.set_backtrace(caller)
+          on_error(@total_timeout)
+          return
+        end
+
+        return elapsed_time
+      end
+
       return @timeout if defined?(@timeout)
 
       return @options.timeout[:connect_timeout] if @state == :idle
@@ -243,6 +255,14 @@ module HTTPX
       @options.timeout[:operation_timeout]
     end
 
+    def deactivate
+      transition(:inactive)
+    end
+
+    def open?
+      @state == :open || @state == :inactive
+    end
+
     private
 
     def connect
@@ -313,7 +333,7 @@ module HTTPX
 
             # exit #consume altogether if all outstanding requests have been dealt with
             return if @pending.size.zero? && @inflight.zero?
-          end unless (interests.nil? || interests == :w || @state == :closing) && !epiped
+          end unless ((ints = interests).nil? || ints == :w || @state == :closing) && !epiped
 
           #
           # tight write loop.
@@ -360,19 +380,18 @@ module HTTPX
             break if interests == :r || @state == :closing || @state == :closed
 
             write_drained = false
-          end unless interests == :r
+          end unless (ints = interests) == :r
 
           send_pending if @state == :open
 
           # return if socket is drained
-          next unless (interests != :r || read_drained) &&
-                      (interests != :w || write_drained)
+          next unless (ints != :r || read_drained) && (ints != :w || write_drained)
 
           # gotta go back to the event loop. It happens when:
           #
           # * the socket is drained of bytes or it's not the interest of the conn to read;
           # * theres nothing more to write, or it's not in the interest of the conn to write;
-          log(level: 3) { "(#{interests}): WAITING FOR EVENTS..." }
+          log(level: 3) { "(#{ints}): WAITING FOR EVENTS..." }
           return
         end
       end
@@ -380,9 +399,7 @@ module HTTPX
 
     def send_pending
       while !@write_buffer.full? && (request = @pending.shift)
-        @inflight += 1
-        @keep_alive_timer.pause if @keep_alive_timer
-        parser.send(request)
+        send_request_to_parser(request)
       end
     end
 
@@ -390,6 +407,15 @@ module HTTPX
       @parser ||= build_parser
     end
 
+    def send_request_to_parser(request)
+      @inflight += 1
+      parser.send(request)
+
+      return unless @state == :inactive
+
+      transition(:active)
+    end
+
     def build_parser(protocol = @io.protocol)
       parser = registry(protocol).new(@write_buffer, @options)
       set_parser_callbacks(parser)
@@ -401,7 +427,8 @@ module HTTPX
         AltSvc.emit(request, response) do |alt_origin, origin, alt_params|
           emit(:altsvc, alt_origin, origin, alt_params)
         end
-        handle_response
+        @response_received_at = Utils.now
+        @inflight -= 1
         request.emit(:response, response)
       end
       parser.on(:altsvc) do |alt_origin, origin, alt_params|
@@ -421,7 +448,7 @@ module HTTPX
       end
       parser.on(:close) do |force|
         transition(:closing)
-        if force
+        if force || @state == :idle
           transition(:closed)
           emit(:close)
         end
@@ -467,15 +494,17 @@ module HTTPX
       when :open
         return if @state == :closed
 
-        total_timeout
-
         @io.connect
         return unless @io.connected?
 
+        @connected_at = Utils.now
+
         send_pending
 
         @timeout = @current_timeout = parser.timeout
         emit(:open)
+      when :inactive
+        return unless @state == :open
       when :closing
         return unless @state == :open
 
@@ -483,15 +512,15 @@ module HTTPX
         return unless @state == :closing
         return unless @write_buffer.empty?
 
-        if @total_timeout
-          @total_timeout.cancel
-          remove_instance_variable(:@total_timeout)
-        end
-
         purge_after_closed
       when :already_open
         nextstate = :open
         send_pending
+      when :active
+        return unless @state == :inactive
+
+        nextstate = :open
+        emit(:activate)
       end
       @state = nextstate
     rescue Errno::ECONNREFUSED,
@@ -507,44 +536,24 @@ module HTTPX
     def purge_after_closed
       @io.close if @io
       @read_buffer.clear
-      if @keep_alive_timer
-        @keep_alive_timer.cancel
-        remove_instance_variable(:@keep_alive_timer)
-      end
-
       remove_instance_variable(:@timeout) if defined?(@timeout)
     end
 
-    def handle_response
-      @inflight -= 1
-      return unless @inflight.zero?
-
-      if @keep_alive_timer
-        @keep_alive_timer.resume
-        @keep_alive_timer.reset
-      else
-        @keep_alive_timer = @timers.after(@keep_alive_timeout) do
-          unless @inflight.zero?
-            log { "(#{@origin}): keep alive timeout expired" }
-            parser.ping
-          end
-        end
-      end
-    end
-
     def on_error(error)
       if error.instance_of?(TimeoutError)
-        if @timeout
-          @timeout -= error.timeout
-          return unless @timeout <= 0
-        end
 
-        if @total_timeout && @total_timeout.fires_in.negative?
-          ex = TotalTimeoutError.new(@total_timeout.interval, "Timed out after #{@total_timeout.interval} seconds")
+        if @total_timeout && @connected_at &&
+           Utils.elapsed_time(@connected_at) > @total_timeout
+          ex = TotalTimeoutError.new(@total_timeout, "Timed out after #{@total_timeout} seconds")
           ex.set_backtrace(error.backtrace)
           error = ex
-        elsif connecting?
-          error = error.to_connection_error
+        else
+          if @timeout
+            @timeout -= error.timeout
+            return unless @timeout <= 0
+          end
+
+          error = error.to_connection_error if connecting?
         end
       end
       handle_error(error)
@@ -559,18 +568,5 @@ module HTTPX
         request.emit(:response, response)
       end
     end
-
-    def total_timeout
-      total = @options.timeout[:total_timeout]
-
-      return unless total
-
-      @total_timeout ||= @timers.after(total) do
-        ex = TotalTimeoutError.new(total, "Timed out after #{total} seconds")
-        ex.set_backtrace(caller)
-        on_error(ex)
-        @parser.close if @parser
-      end
-    end
   end
 end

data/lib/httpx/domain_name.rb

@@ -123,7 +123,7 @@ module HTTPX
 
       # RFC 6265 #4.1.1
       # Domain-value must be a subdomain.
-      @domain && self <= domain && domain <= @domain ? true : false
+      @domain && self <= domain && domain <= @domain
     end
 
     # def ==(other)

data/lib/httpx/errors.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module HTTPX
-  Error = Class.new(StandardError)
+  class Error < StandardError; end
 
-  UnsupportedSchemeError = Class.new(Error)
+  class UnsupportedSchemeError < Error; end
 
-  TimeoutError = Class.new(Error) do
+  class TimeoutError < Error
     attr_reader :timeout
 
     def initialize(timeout, message)
@@ -20,17 +20,17 @@ module HTTPX
     end
   end
 
-  TotalTimeoutError = Class.new(TimeoutError)
+  class TotalTimeoutError < TimeoutError; end
 
-  ConnectTimeoutError = Class.new(TimeoutError)
+  class ConnectTimeoutError < TimeoutError; end
 
-  SettingsTimeoutError = Class.new(TimeoutError)
+  class SettingsTimeoutError < TimeoutError; end
 
-  ResolveTimeoutError = Class.new(TimeoutError)
+  class ResolveTimeoutError < TimeoutError; end
 
-  ResolveError = Class.new(Error)
+  class ResolveError < Error; end
 
-  NativeResolveError = Class.new(ResolveError) do
+  class NativeResolveError < ResolveError
     attr_reader :connection, :host
 
     def initialize(connection, host, message = "Can't resolve #{host}")
@@ -40,7 +40,7 @@ module HTTPX
     end
   end
 
-  HTTPError = Class.new(Error) do
+  class HTTPError < Error
     attr_reader :response
 
     def initialize(response)
@@ -53,5 +53,5 @@ module HTTPX
     end
   end
 
-  MisdirectedRequestError = Class.new(HTTPError)
+  class MisdirectedRequestError < HTTPError; end
 end

data/lib/httpx/extensions.rb

@@ -54,6 +54,51 @@ module HTTPX
     Numeric.__send__(:include, NegMethods)
   end
 
+  module HashExtensions
+    refine Hash do
+      def compact
+        h = {}
+        each do |key, value|
+          h[key] = value unless value == nil
+        end
+        h
+      end unless Hash.method_defined?(:compact)
+    end
+  end
+
+  module ArrayExtensions
+    refine Array do
+
+      def filter_map
+        return to_enum(:filter_map) unless block_given?
+
+        each_with_object([]) do |item, res|
+          processed = yield(item)
+          res << processed if processed
+        end
+      end unless Array.method_defined?(:filter_map)
+
+      def sum(accumulator = 0, &block)
+        values = block_given? ? map(&block) : self
+        values.inject(accumulator, :+)
+      end unless Array.method_defined?(:sum)
+    end
+  end
+
+  module IOExtensions
+    refine IO do
+      # provides a fallback for rubies where IO#wait isn't implemented,
+      # but IO#wait_readable and IO#wait_writable are.
+      def wait(timeout = nil, _mode = :read_write)
+        r, w = IO.select([self], [self], nil, timeout)
+
+        return unless r || w
+
+        self
+      end unless IO.method_defined?(:wait) && IO.instance_method(:wait).arity == 2
+    end
+  end
+
   module RegexpExtensions
     # If you wonder why this is there: the oauth feature uses a refinement to enhance the
     # Regexp class locally with #match? , but this is never tested, because ActiveSupport
@@ -77,13 +122,14 @@ module HTTPX
       end
 
       def authority
-        port_string = port == default_port ? nil : ":#{port}"
-        "#{host}#{port_string}"
-      end
+        return host if port == default_port
+
+        "#{host}:#{port}"
+      end unless URI::HTTP.method_defined?(:authority)
 
       def origin
         "#{scheme}://#{authority}"
-      end
+      end unless URI::HTTP.method_defined?(:origin)
 
       def altsvc_match?(uri)
         uri = URI.parse(uri)

data/lib/httpx/headers.rb

@@ -57,7 +57,7 @@ module HTTPX
     def merge(other)
       headers = dup
       other.each do |field, value|
-        headers[field] = value
+        headers[downcased(field)] = value
       end
       headers
     end

data/lib/httpx/io/ssl.rb

@@ -7,9 +7,9 @@ module HTTPX
 
   class SSL < TCP
     TLS_OPTIONS = if OpenSSL::SSL::SSLContext.instance_methods.include?(:alpn_protocols)
-      { alpn_protocols: %w[h2 http/1.1] }
+      { alpn_protocols: %w[h2 http/1.1].freeze }.freeze
     else
-      {}
+      {}.freeze
     end
 
     def initialize(_, _, options)
@@ -134,7 +134,7 @@ module HTTPX
       server_cert = @io.peer_cert
 
       "#{super}\n\n" \
-      "SSL connection using #{@io.ssl_version} / #{Array(@io.cipher).first}\n" \
+        "SSL connection using #{@io.ssl_version} / #{Array(@io.cipher).first}\n" \
         "ALPN, server accepted to use #{protocol}\n" \
         "Server certificate:\n" \
         " subject: #{server_cert.subject}\n" \

data/lib/httpx/io/tls.rb

@@ -4,7 +4,7 @@ require "openssl"
 
 module HTTPX
   class TLS < TCP
-    Error = Class.new(StandardError)
+    class Error < StandardError; end
 
     def initialize(_, _, options)
       super
@@ -194,15 +194,15 @@ module HTTPX
       server_cert = @peer_cert
 
       "#{super}\n\n" \
-        "SSL connection using #{@ctx.ssl_version} / #{Array(@ctx.cipher).first}\n" \
-        "ALPN, server accepted to use #{protocol}\n" +
+      "SSL connection using #{@ctx.ssl_version} / #{Array(@ctx.cipher).first}\n" \
+      "ALPN, server accepted to use #{protocol}\n" +
         (if server_cert
            "Server certificate:\n" \
-                 " subject: #{server_cert.subject}\n" \
-                 " start date: #{server_cert.not_before}\n" \
-                 " expire date: #{server_cert.not_after}\n" \
-                 " issuer: #{server_cert.issuer}\n" \
-                 " SSL certificate verify ok."
+             " subject: #{server_cert.subject}\n" \
+             " start date: #{server_cert.not_before}\n" \
+             " expire date: #{server_cert.not_after}\n" \
+             " issuer: #{server_cert.issuer}\n" \
+             " SSL certificate verify ok."
          else
            "SSL certificate verify failed."
          end

data/lib/httpx/loggable.rb

@@ -24,15 +24,13 @@ module HTTPX
       debug_stream << message
     end
 
-    if !Exception.instance_methods.include?(:full_message)
+    if Exception.instance_methods.include?(:full_message)
 
       def log_exception(ex, level: @options.debug_level, color: nil)
         return unless @options.debug
         return unless @options.debug_level >= level
 
-        message = +"#{ex.message} (#{ex.class})"
-        message << "\n" << ex.backtrace.join("\n") unless ex.backtrace.nil?
-        log(level: level, color: color) { message }
+        log(level: level, color: color) { ex.full_message }
       end
 
     else
@@ -41,7 +39,9 @@ module HTTPX
         return unless @options.debug
         return unless @options.debug_level >= level
 
-        log(level: level, color: color) { ex.full_message }
+        message = +"#{ex.message} (#{ex.class})"
+        message << "\n" << ex.backtrace.join("\n") unless ex.backtrace.nil?
+        log(level: level, color: color) { message }
       end
 
     end