http 3.1.0 → 5.3.1

data/lib/http/timeout/global.rb

@@ -3,27 +3,25 @@
 require "timeout"
 require "io/wait"
 
-require "http/timeout/per_operation"
+require "http/timeout/null"
 
 module HTTP
   module Timeout
-    class Global < PerOperation
-      attr_reader :time_left, :total_timeout
-
+    class Global < Null
       def initialize(*args)
         super
-        reset_counter
+
+        @timeout = @time_left = options.fetch(:global_timeout)
       end
 
       # To future me: Don't remove this again, past you was smarter.
       def reset_counter
-        @time_left = connect_timeout + read_timeout + write_timeout
-        @total_timeout = time_left
+        @time_left = @timeout
       end
 
       def connect(socket_class, host, port, nodelay = false)
         reset_timer
-        ::Timeout.timeout(time_left, TimeoutError) do
+        ::Timeout.timeout(@time_left, ConnectTimeoutError) do
           @socket = socket_class.open(host, port)
           @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
@@ -37,19 +35,17 @@ module HTTP
         begin
           @socket.connect_nonblock
         rescue IO::WaitReadable
-          IO.select([@socket], nil, nil, time_left)
-          log_time
+          wait_readable_or_timeout
           retry
         rescue IO::WaitWritable
-          IO.select(nil, [@socket], nil, time_left)
-          log_time
+          wait_writable_or_timeout
           retry
         end
       end
 
       # Read from the socket
-      def readpartial(size)
-        perform_io { read_nonblock(size) }
+      def readpartial(size, buffer = nil)
+        perform_io { read_nonblock(size, buffer) }
       end
 
       # Write to the socket
@@ -61,22 +57,12 @@ module HTTP
 
       private
 
-      if RUBY_VERSION < "2.1.0"
-        def read_nonblock(size)
-          @socket.read_nonblock(size)
-        end
-
-        def write_nonblock(data)
-          @socket.write_nonblock(data)
-        end
-      else
-        def read_nonblock(size)
-          @socket.read_nonblock(size, :exception => false)
-        end
+      def read_nonblock(size, buffer = nil)
+        @socket.read_nonblock(size, buffer, :exception => false)
+      end
 
-        def write_nonblock(data)
-          @socket.write_nonblock(data, :exception => false)
-        end
+      def write_nonblock(data)
+        @socket.write_nonblock(data, :exception => false)
       end
 
       # Perform the given I/O operation with the given argument
@@ -84,20 +70,18 @@ module HTTP
         reset_timer
 
         loop do
-          begin
-            result = yield
-
-            case result
-            when :wait_readable then wait_readable_or_timeout
-            when :wait_writable then wait_writable_or_timeout
-            when NilClass       then return :eof
-            else                return result
-            end
-          rescue IO::WaitReadable
-            wait_readable_or_timeout
-          rescue IO::WaitWritable
-            wait_writable_or_timeout
+          result = yield
+
+          case result
+          when :wait_readable then wait_readable_or_timeout
+          when :wait_writable then wait_writable_or_timeout
+          when NilClass       then return :eof
+          else                return result
           end
+        rescue IO::WaitReadable
+          wait_readable_or_timeout
+        rescue IO::WaitWritable
+          wait_writable_or_timeout
         end
       rescue EOFError
         :eof
@@ -105,13 +89,13 @@ module HTTP
 
       # Wait for a socket to become readable
       def wait_readable_or_timeout
-        @socket.to_io.wait_readable(time_left)
+        @socket.to_io.wait_readable(@time_left)
         log_time
       end
 
       # Wait for a socket to become writable
       def wait_writable_or_timeout
-        @socket.to_io.wait_writable(time_left)
+        @socket.to_io.wait_writable(@time_left)
         log_time
       end
 
@@ -123,9 +107,7 @@ module HTTP
 
       def log_time
         @time_left -= (Time.now - @started)
-        if time_left <= 0
-          raise TimeoutError, "Timed out after using the allocated #{total_timeout} seconds"
-        end
+        raise TimeoutError, "Timed out after using the allocated #{@timeout} seconds" if @time_left <= 0
 
         reset_timer
       end

data/lib/http/timeout/null.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
-require "forwardable"
 require "io/wait"
 
 module HTTP
   module Timeout
     class Null
-      extend Forwardable
-
-      def_delegators :@socket, :close, :closed?
-
       attr_reader :options, :socket
 
-      def initialize(options = {}) # rubocop:disable Style/OptionHash
+      def initialize(options = {})
         @options = options
       end
 
@@ -27,6 +22,14 @@ module HTTP
         @socket.connect
       end
 
+      def close
+        @socket&.close
+      end
+
+      def closed?
+        @socket&.closed?
+      end
+
       # Configures the SSL connection and starts the connection
       def start_tls(host, ssl_socket_class, ssl_context)
         @socket = ssl_socket_class.new(socket, ssl_context)
@@ -36,13 +39,14 @@ module HTTP
         connect_ssl
 
         return unless ssl_context.verify_mode == OpenSSL::SSL::VERIFY_PEER
+        return if ssl_context.respond_to?(:verify_hostname) && !ssl_context.verify_hostname
 
         @socket.post_connection_check(host)
       end
 
       # Read from the socket
-      def readpartial(size)
-        @socket.readpartial(size)
+      def readpartial(size, buffer = nil)
+        @socket.readpartial(size, buffer)
       rescue EOFError
         :eof
       end

data/lib/http/timeout/per_operation.rb

@@ -11,8 +11,6 @@ module HTTP
       WRITE_TIMEOUT = 0.25
       READ_TIMEOUT = 0.25
 
-      attr_reader :read_timeout, :write_timeout, :connect_timeout
-
       def initialize(*args)
         super
 
@@ -22,7 +20,7 @@ module HTTP
       end
 
       def connect(socket_class, host, port, nodelay = false)
-        ::Timeout.timeout(connect_timeout, TimeoutError) do
+        ::Timeout.timeout(@connect_timeout, ConnectTimeoutError) do
           @socket = socket_class.open(host, port)
           @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
@@ -36,65 +34,42 @@ module HTTP
         end
       end
 
-      # NIO with exceptions
-      if RUBY_VERSION < "2.1.0"
-        # Read data from the socket
-        def readpartial(size)
-          rescue_readable do
-            @socket.read_nonblock(size)
-          end
-        rescue EOFError
-          :eof
-        end
-
-        # Write data to the socket
-        def write(data)
-          rescue_writable do
-            @socket.write_nonblock(data)
-          end
-        rescue EOFError
-          :eof
-        end
-
-      # NIO without exceptions
-      else
-        # Read data from the socket
-        def readpartial(size)
-          timeout = false
-          loop do
-            result = @socket.read_nonblock(size, :exception => false)
-
-            return :eof   if result.nil?
-            return result if result != :wait_readable
-
-            raise TimeoutError, "Read timed out after #{read_timeout} seconds" if timeout
-            # marking the socket for timeout. Why is this not being raised immediately?
-            # it seems there is some race-condition on the network level between calling
-            # #read_nonblock and #wait_readable, in which #read_nonblock signalizes waiting
-            # for reads, and when waiting for x seconds, it returns nil suddenly without completing
-            # the x seconds. In a normal case this would be a timeout on wait/read, but it can
-            # also mean that the socket has been closed by the server. Therefore we "mark" the
-            # socket for timeout and try to read more bytes. If it returns :eof, it's all good, no
-            # timeout. Else, the first timeout was a proper timeout.
-            # This hack has to be done because io/wait#wait_readable doesn't provide a value for when
-            # the socket is closed by the server, and HTTP::Parser doesn't provide the limit for the chunks.
-            timeout = true unless @socket.to_io.wait_readable(read_timeout)
-          end
+      # Read data from the socket
+      def readpartial(size, buffer = nil)
+        timeout = false
+        loop do
+          result = @socket.read_nonblock(size, buffer, :exception => false)
+
+          return :eof   if result.nil?
+          return result if result != :wait_readable
+
+          raise TimeoutError, "Read timed out after #{@read_timeout} seconds" if timeout
+
+          # marking the socket for timeout. Why is this not being raised immediately?
+          # it seems there is some race-condition on the network level between calling
+          # #read_nonblock and #wait_readable, in which #read_nonblock signalizes waiting
+          # for reads, and when waiting for x seconds, it returns nil suddenly without completing
+          # the x seconds. In a normal case this would be a timeout on wait/read, but it can
+          # also mean that the socket has been closed by the server. Therefore we "mark" the
+          # socket for timeout and try to read more bytes. If it returns :eof, it's all good, no
+          # timeout. Else, the first timeout was a proper timeout.
+          # This hack has to be done because io/wait#wait_readable doesn't provide a value for when
+          # the socket is closed by the server, and HTTP::Parser doesn't provide the limit for the chunks.
+          timeout = true unless @socket.to_io.wait_readable(@read_timeout)
         end
+      end
 
-        # Write data to the socket
-        def write(data)
-          timeout = false
-          loop do
-            result = @socket.write_nonblock(data, :exception => false)
-            return result unless result == :wait_writable
+      # Write data to the socket
+      def write(data)
+        timeout = false
+        loop do
+          result = @socket.write_nonblock(data, :exception => false)
+          return result unless result == :wait_writable
 
-            raise TimeoutError, "Write timed out after #{write_timeout} seconds" if timeout
+          raise TimeoutError, "Write timed out after #{@write_timeout} seconds" if timeout
 
-            timeout = true unless @socket.to_io.wait_writable(write_timeout)
-          end
+          timeout = true unless @socket.to_io.wait_writable(@write_timeout)
         end
-
       end
     end
   end

data/lib/http/uri.rb

@@ -9,7 +9,6 @@ module HTTP
     def_delegators :@uri, :scheme, :normalized_scheme, :scheme=
     def_delegators :@uri, :user, :normalized_user, :user=
     def_delegators :@uri, :password, :normalized_password, :password=
-    def_delegators :@uri, :host, :normalized_host, :host=
     def_delegators :@uri, :authority, :normalized_authority, :authority=
     def_delegators :@uri, :origin, :origin=
     def_delegators :@uri, :normalized_port, :port=
@@ -20,12 +19,40 @@ module HTTP
     def_delegators :@uri, :fragment, :normalized_fragment, :fragment=
     def_delegators :@uri, :omit, :join, :normalize
 
+    # Host, either a domain name or IP address. If the host is an IPv6 address, it will be returned
+    # without brackets surrounding it.
+    #
+    # @return [String] The host of the URI
+    attr_reader :host
+
+    # Normalized host, either a domain name or IP address. If the host is an IPv6 address, it will
+    # be returned without brackets surrounding it.
+    #
+    # @return [String] The normalized host of the URI
+    attr_reader :normalized_host
+
     # @private
     HTTP_SCHEME = "http"
 
     # @private
     HTTPS_SCHEME = "https"
 
+    # @private
+    PERCENT_ENCODE = /[^\x21-\x7E]+/.freeze
+
+    # @private
+    NORMALIZER = lambda do |uri|
+      uri = HTTP::URI.parse uri
+
+      HTTP::URI.new(
+        :scheme    => uri.normalized_scheme,
+        :authority => uri.normalized_authority,
+        :path      => uri.path.empty? ? "/" : percent_encode(Addressable::URI.normalize_path(uri.path)),
+        :query     => percent_encode(uri.query),
+        :fragment  => uri.normalized_fragment
+      )
+    end
+
     # Parse the given URI string, returning an HTTP::URI object
     #
     # @param [HTTP::URI, String, #to_str] uri to parse
@@ -47,6 +74,19 @@ module HTTP
       Addressable::URI.form_encode(form_values, sort)
     end
 
+    # Percent-encode all characters matching a regular expression.
+    #
+    # @param [String] string raw string
+    #
+    # @return [String] encoded value
+    #
+    # @private
+    def self.percent_encode(string)
+      string&.gsub(PERCENT_ENCODE) do |substr|
+        substr.encode(Encoding::UTF_8).bytes.map { |c| format("%%%02X", c) }.join
+      end
+    end
+
     # Creates an HTTP::URI instance from the given options
     #
     # @param [Hash, Addressable::URI] options_or_uri
@@ -70,6 +110,9 @@ module HTTP
       else
         raise TypeError, "expected Hash for options, got #{options_or_uri.class}"
       end
+
+      @host = process_ipv6_brackets(@uri.host)
+      @normalized_host = process_ipv6_brackets(@uri.normalized_host)
     end
 
     # Are these URI objects equal? Normalizes both URIs prior to comparison
@@ -97,6 +140,17 @@ module HTTP
       @hash ||= to_s.hash * -1
     end
 
+    # Sets the host component for the URI.
+    #
+    # @param [String, #to_str] new_host The new host component.
+    # @return [void]
+    def host=(new_host)
+      @uri.host = process_ipv6_brackets(new_host, :brackets => true)
+
+      @host = process_ipv6_brackets(@uri.host)
+      @normalized_host = process_ipv6_brackets(@uri.normalized_host)
+    end
+
     # Port number, either as specified or the default if unspecified
     #
     # @return [Integer] port number
@@ -133,5 +187,25 @@ module HTTP
     def inspect
       format("#<%s:0x%014x URI:%s>", self.class.name, object_id << 1, to_s)
     end
+
+    private
+
+    # Process a URI host, adding or removing surrounding brackets if the host is an IPv6 address.
+    #
+    # @param [Boolean] brackets When true, brackets will be added to IPv6 addresses if missing. When
+    #   false, they will be removed if present.
+    #
+    # @return [String] Host with IPv6 address brackets added or removed
+    def process_ipv6_brackets(raw_host, brackets: false)
+      ip = IPAddr.new(raw_host)
+
+      if ip.ipv6?
+        brackets ? "[#{ip}]" : ip.to_s
+      else
+        raw_host
+      end
+    rescue IPAddr::Error
+      raw_host
+    end
   end
 end

data/lib/http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP
-  VERSION = "3.1.0"
+  VERSION = "5.3.1"
 end

data/lib/http.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "http/parser"
-
 require "http/errors"
 require "http/timeout/null"
 require "http/timeout/per_operation"
 require "http/timeout/global"
 require "http/chainable"
 require "http/client"
+require "http/retriable/client"
 require "http/connection"
 require "http/options"
+require "http/feature"
 require "http/request"
 require "http/request/writer"
 require "http/response"