excon 0.99.0 → 1.0.0

data/excon.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
     "README.md",
     "excon.gemspec"
   ]
+  s.required_ruby_version = '>= 2.7.0'
 
   s.add_development_dependency('rspec', '>= 3.5.0')
   s.add_development_dependency('activesupport')

data/lib/excon/connection.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'ipaddr'
 
 module Excon
   class Connection
@@ -230,6 +229,13 @@ module Excon
     def request(params={}, &block)
       # @data has defaults, merge in new params to override
       datum = @data.merge(params)
+
+      # Set the deadline for the current request in order to determine when we have run out of time.
+      # Only set when a request timeout has been defined.
+      if datum[:timeout]
+        datum[:deadline] = Process.clock_gettime(Process::CLOCK_MONOTONIC) + datum[:timeout]
+      end
+
       datum[:headers] = @data[:headers].merge(datum[:headers] || {})
 
       validate_params(:request, params, datum[:middlewares])
@@ -244,16 +250,17 @@ module Excon
         datum[:headers]['Authorization'] ||= 'Basic ' + ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
       end
 
+      host_key = datum[:headers].keys.detect {|k| k.casecmp('Host') == 0 } || 'Host'
       if datum[:scheme] == UNIX
-        datum[:headers]['Host']   ||= ''
+        datum[:headers][host_key] ||= ''
       else
-        datum[:headers]['Host']   ||= datum[:host] + port_string(datum)
+        datum[:headers][host_key] ||= datum[:host] + port_string(datum)
       end
 
       # RFC 7230, section 5.4, states that the Host header SHOULD be the first one # to be present.
       # Some web servers will reject the request if it comes too late, so let's hoist it to the top.
-      if (host = datum[:headers].delete('Host'))
-        datum[:headers] = { 'Host' => host }.merge(datum[:headers])
+      if (host = datum[:headers].delete(host_key))
+        datum[:headers] = { host_key => host }.merge(datum[:headers])
       end
 
       # default to GET if no method specified
@@ -439,6 +446,12 @@ module Excon
         raise ArgumentError.new("Invalid validation type '#{validation}'")
       end
 
+      if validation == :connection && params[:omit_default_port] != true
+        Excon.display_warning(
+          'The `omit_default_port` connection option is deprecated, please use `include_default_port` instead.'
+        )
+      end
+
       invalid_keys = params.keys - valid_keys
       unless invalid_keys.empty?
         Excon.display_warning("Invalid Excon #{validation} keys: #{invalid_keys.map(&:inspect).join(', ')}")

data/lib/excon/constants.rb

@@ -1,32 +1,31 @@
 # frozen_string_literal: true
 module Excon
-
   CR_NL = "\r\n"
 
-  DEFAULT_CA_FILE = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "data", "cacert.pem"))
+  DEFAULT_CA_FILE = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'cacert.pem'))
 
-  DEFAULT_CHUNK_SIZE = 1048576 # 1 megabyte
+  DEFAULT_CHUNK_SIZE = 1_048_576 # 1 megabyte
 
   # avoid overwrite if somebody has redefined
-  unless const_defined?(:CHUNK_SIZE)
-    CHUNK_SIZE = DEFAULT_CHUNK_SIZE
-  end
+  CHUNK_SIZE = DEFAULT_CHUNK_SIZE unless const_defined?(:CHUNK_SIZE)
 
   DEFAULT_REDIRECT_LIMIT = 10
 
   DEFAULT_RETRY_LIMIT = 4
 
   DEFAULT_RETRY_ERRORS = [
-    Excon::Error::Timeout,
+    Excon::Error::RequestTimeout,
+    Excon::Error::Server,
     Excon::Error::Socket,
-    Excon::Error::HTTPStatus
-  ]
+    Excon::Error::Timeout,
+    Excon::Error::TooManyRequests
+  ].freeze
 
   FORCE_ENC = CR_NL.respond_to?(:force_encoding)
 
   HTTP_1_1 = " HTTP/1.1\r\n"
 
-  HTTP_VERBS = %w{connect delete get head options patch post put trace}
+  HTTP_VERBS = %w[connect delete get head options patch post put trace].freeze
 
   HTTPS = 'https'
 
@@ -40,86 +39,90 @@ module Excon
 
   VERSIONS = "#{USER_AGENT} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
 
-  VALID_REQUEST_KEYS = [
-    :allow_unstubbed_requests,
-    :body,
-    :chunk_size,
-    :debug_request,
-    :debug_response,
-    :headers,
-    :instrumentor, # Used for setting logging within Connection
-    :logger,
-    :method,
-    :middlewares,
-    :password,
-    :path,
-    :persistent,
-    :pipeline,
-    :query,
-    :read_timeout,
-    :request_block,
-    :response_block,
-    :stubs,
-    :user,
-    :versions,
-    :write_timeout
-  ]
-
-  VALID_CONNECTION_KEYS = VALID_REQUEST_KEYS + [
-    :ciphers,
-    :client_key,
-    :client_key_data,
-    :client_key_pass,
-    :client_cert,
-    :client_cert_data,
-    :client_chain,
-    :client_chain_data,
-    :certificate,
-    :certificate_path,
-    :disable_proxy,
-    :private_key,
-    :private_key_path,
-    :connect_timeout,
-    :family,
-    :keepalive,
-    :host,
-    :hostname,
-    :omit_default_port,
-    :nonblock,
-    :reuseaddr,
-    :port,
-    :proxy,
-    :scheme,
-    :socket,
-    :ssl_ca_file,
-    :ssl_ca_path,
-    :ssl_cert_store,
-    :ssl_verify_callback,
-    :ssl_verify_peer,
-    :ssl_verify_peer_host,
-    :ssl_verify_hostname,
-    :ssl_version,
-    :ssl_min_version,
-    :ssl_max_version,
-    :ssl_security_level,
-    :ssl_proxy_headers,
-    :ssl_uri_schemes,
-    :tcp_nodelay,
-    :thread_safe_sockets,
-    :uri_parser,
+  VALID_REQUEST_KEYS = %i[
+    allow_unstubbed_requests
+    body
+    chunk_size
+    debug_request
+    debug_response
+    dns_timeouts
+    headers
+    instrumentor
+    logger
+    method
+    middlewares
+    password
+    path
+    persistent
+    pipeline
+    query
+    read_timeout
+    request_block
+    resolv_resolver
+    response_block
+    stubs
+    timeout
+    user
+    versions
+    write_timeout
+  ].freeze
+
+  VALID_CONNECTION_KEYS = VALID_REQUEST_KEYS + %i[
+    ciphers
+    client_key
+    client_key_data
+    client_key_pass
+    client_cert
+    client_cert_data
+    client_chain
+    client_chain_data
+    certificate
+    certificate_path
+    disable_proxy
+    private_key
+    private_key_path
+    connect_timeout
+    family
+    keepalive
+    host
+    hostname
+    include_default_port
+    omit_default_port
+    nonblock
+    reuseaddr
+    port
+    proxy
+    scheme
+    socket
+    ssl_ca_file
+    ssl_ca_path
+    ssl_cert_store
+    ssl_verify_callback
+    ssl_verify_peer
+    ssl_verify_peer_host
+    ssl_verify_hostname
+    ssl_version
+    ssl_min_version
+    ssl_max_version
+    ssl_security_level
+    ssl_proxy_headers
+    ssl_uri_schemes
+    tcp_nodelay
+    thread_safe_sockets
+    uri_parser
   ]
 
   DEPRECATED_VALID_REQUEST_KEYS = {
-    :captures => 'Mock',
-    :expects => 'Expects',
-    :idempotent => 'Idempotent',
-    :instrumentor_name => 'Instrumentor',
-    :mock => 'Mock',
-    :retries_remaining => 'Idempotent', # referenced in Instrumentor, but only relevant with Idempotent
-    :retry_errors => 'Idempotent',
-    :retry_interval => 'Idempotent',
-    :retry_limit => 'Idempotent' # referenced in Instrumentor, but only relevant with Idempotent
-  }
+    captures: 'Mock',
+    expects: 'Expects',
+    idempotent: 'Idempotent',
+    instrumentor_name: 'Instrumentor',
+    mock: 'Mock',
+    retries_remaining: 'Idempotent', # referenced in Instrumentor, but only relevant with Idempotent
+    retry_errors: 'Idempotent',
+    retry_interval: 'Idempotent',
+    retry_limit: 'Idempotent' # referenced in Instrumentor, but only relevant with Idempotent
+  }.freeze
 
   unless ::IO.const_defined?(:WaitReadable)
     class ::IO
@@ -132,43 +135,48 @@ module Excon
       module WaitWritable; end
     end
   end
+
   # these come last as they rely on the above
   DEFAULTS = {
-    :chunk_size           => CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
+    chunk_size: CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
     # see https://wiki.mozilla.org/Security/Server_Side_TLS#Intermediate_compatibility_.28default.29
     # list provided then had DES related things sorted to the end
-    :ciphers              => 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:DES-CBC3-SHA:!DSS',
-    :connect_timeout      => 60,
-    :debug_request        => false,
-    :debug_response       => false,
-    :headers              => {
+    ciphers: 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:DES-CBC3-SHA:!DSS',
+    connect_timeout: 60,
+    debug_request: false,
+    debug_response: false,
+    dns_timeouts: nil, # nil allows Resolv::DNS default timeout value (see https://ruby-doc.org/3.2.2/stdlibs/resolv/Resolv/DNS.html#method-i-timeouts-3D)
+    headers: {
       'User-Agent' => USER_AGENT,
-      'Accept'     =>  '*/*'
+      'Accept' => '*/*'
     },
-    :idempotent           => false,
-    :instrumentor_name    => 'excon',
-    :middlewares          => [
+    idempotent: false,
+    instrumentor_name: 'excon',
+    middlewares: [
       Excon::Middleware::ResponseParser,
+      Excon::Middleware::Decompress,
       Excon::Middleware::Expects,
       Excon::Middleware::Idempotent,
       Excon::Middleware::Instrumentor,
       Excon::Middleware::Mock
     ],
-    :mock                 => false,
-    :nonblock             => true,
-    :omit_default_port    => false,
-    :persistent           => false,
-    :read_timeout         => 60,
-    :retry_errors         => DEFAULT_RETRY_ERRORS,
-    :retry_limit          => DEFAULT_RETRY_LIMIT,
-    :ssl_verify_peer      => true,
-    :ssl_uri_schemes      => [HTTPS],
-    :stubs                => :global,
-    :tcp_nodelay          => false,
-    :thread_safe_sockets  => true,
-    :uri_parser           => URI,
-    :versions             => VERSIONS,
-    :write_timeout        => 60
+    mock: false,
+    include_default_port: false,
+    nonblock: true,
+    omit_default_port: true,
+    persistent: false,
+    read_timeout: 60,
+    resolv_resolver: nil,
+    retry_errors: DEFAULT_RETRY_ERRORS,
+    retry_limit: DEFAULT_RETRY_LIMIT,
+    ssl_verify_peer: true,
+    ssl_uri_schemes: [HTTPS],
+    stubs: :global,
+    tcp_nodelay: false,
+    thread_safe_sockets: true,
+    timeout: nil,
+    uri_parser: URI,
+    versions: VERSIONS,
+    write_timeout: 60
   }
-
 end

data/lib/excon/middlewares/decompress.rb

@@ -1,41 +1,36 @@
 # frozen_string_literal: true
+
 module Excon
   module Middleware
     class Decompress < Excon::Middleware::Base
-
       INFLATE_ZLIB_OR_GZIP  = 47 # Zlib::MAX_WBITS + 32
       INFLATE_RAW           = -15 # Zlib::MAX_WBITS * -1
 
       def request_call(datum)
-        unless datum.has_key?(:response_block)
-          key = datum[:headers].keys.detect {|k| k.to_s.casecmp('Accept-Encoding') == 0 } || 'Accept-Encoding'
-          if datum[:headers][key].to_s.empty?
-            datum[:headers][key] = 'deflate, gzip'
-          end
+        unless datum.key?(:response_block)
+          key = datum[:headers].keys.detect { |k| k.to_s.casecmp('Accept-Encoding').zero? } || 'Accept-Encoding'
+          datum[:headers][key] = 'deflate, gzip' if datum[:headers][key].to_s.empty?
         end
         @stack.request_call(datum)
       end
 
       def response_call(datum)
         body = datum[:response][:body]
-        unless datum.has_key?(:response_block) || body.nil? || body.empty?
-          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Encoding') == 0 })
-            encodings = Utils.split_header_value(datum[:response][:headers][key])
-            if (encoding = encodings.last)
-              if encoding.casecmp('deflate') == 0
-                datum[:response][:body] = begin
-                  Zlib::Inflate.new(INFLATE_ZLIB_OR_GZIP).inflate(body)
-                rescue Zlib::DataError # fallback to raw on error
-                  Zlib::Inflate.new(INFLATE_RAW).inflate(body)
-                end
-                encodings.pop
-              elsif encoding.casecmp('gzip') == 0 || encoding.casecmp('x-gzip') == 0
-                datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(body)).read
-                encodings.pop
-              end
-              datum[:response][:headers][key] = encodings.join(', ')
+        if !(datum.key?(:response_block) || body.nil? || body.empty?) &&
+           (key = datum[:response][:headers].keys.detect { |k| k.casecmp('Content-Encoding').zero? })
+          encodings = Utils.split_header_value(datum[:response][:headers][key])
+          if encodings.last.casecmp('deflate').zero?
+            datum[:response][:body] = begin
+              Zlib::Inflate.new(INFLATE_ZLIB_OR_GZIP).inflate(body)
+            rescue Zlib::DataError # fallback to raw on error
+              Zlib::Inflate.new(INFLATE_RAW).inflate(body)
             end
+            encodings.pop
+          elsif encodings.last.casecmp('gzip').zero? || encodings.last.casecmp('x-gzip').zero?
+            datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(body)).read
+            encodings.pop
           end
+          datum[:response][:headers][key] = encodings.join(', ')
         end
         @stack.response_call(datum)
       end

data/lib/excon/socket.rb

@@ -25,6 +25,13 @@ module Excon
     else # Ruby <= 2.0
       [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
     end
+    # Maps a socket operation to a timeout property.
+    OPERATION_TO_TIMEOUT = {
+      :connect_read => :connect_timeout,
+      :connect_write => :connect_timeout,
+      :read => :read_timeout,
+      :write => :write_timeout
+    }.freeze
 
     def params
       Excon.display_warning('Excon::Socket#params is deprecated use Excon::Socket#data instead.')
@@ -46,14 +53,16 @@ module Excon
       @nonblock = data[:nonblock]
       @port ||= @data[:port] || 80
       @read_buffer = String.new
+      @read_offset = 0
       @eof = false
       @backend_eof = false
+
       connect
     end
 
     def read(max_length = nil)
       if @eof
-        return max_length ? nil : ''
+        max_length ? nil : ''
       elsif @nonblock
         read_nonblock(max_length)
       else
@@ -62,22 +71,24 @@ module Excon
     end
 
     def readline
-      if @nonblock && RUBY_VERSION.to_f > 1.8_7
+      if @nonblock
         result = String.new
-        block = @read_buffer
-        @read_buffer = String.new
+        block = consume_read_buffer
 
         loop do
           idx = block.index("\n")
+
           if idx.nil?
             result << block
           else
-            result << block.slice!(0, idx+1)
-            add_to_read_buffer(block)
+            result << block[0..idx]
+            rewind_read_buffer(block, idx)
             break
           end
+
           block = read_nonblock(@data[:chunk_size]) || raise(EOFError)
         end
+
         result
       else # nonblock/legacy
         begin
@@ -121,7 +132,17 @@ module Excon
         family = @data[:proxy][:family]
       end
 
-      Resolv.each_address(hostname) do |ip|
+      resolver = @data[:resolv_resolver] || Resolv::DefaultResolver
+
+      # Deprecated
+      if @data[:dns_timeouts]
+        Excon.display_warning('dns_timeouts is deprecated, use resolv_resolver instead.')
+        dns_resolver = Resolv::DNS.new
+        dns_resolver.timeouts = @data[:dns_timeouts]
+        resolver = Resolv.new([Resolv::Hosts.new, dns_resolver])
+      end
+
+      resolver.each_address(hostname) do |ip|
         # already succeeded on previous addrinfo
         if @socket
           break
@@ -187,20 +208,48 @@ module Excon
       end
     end
 
-    def add_to_read_buffer(str)
-      @read_buffer << str
+    # Consume any bytes remaining in the read buffer before making a system call.
+    def consume_read_buffer
+      block = @read_buffer[@read_offset..-1]
+
+      @read_offset = @read_buffer.length
+
+      block
+    end
+
+    # Rewind the read buffer to just after the given index.
+    # The offset is moved back to the start of the current chunk and then forward until just after the index.
+    def rewind_read_buffer(chunk, idx)
+      @read_offset = @read_offset - chunk.length + (idx + 1)
       @eof = false
     end
 
     def read_nonblock(max_length)
       begin
+        if @read_offset != 0 && @read_offset >= @read_buffer.length
+          # Clear the buffer so we can test for emptiness below
+          @read_buffer.clear
+          # Reset the offset so it matches the length of the buffer when empty.
+          @read_offset = 0
+        end
+
         if max_length
-          until @backend_eof || @read_buffer.length >= max_length
-            @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
+          until @backend_eof || readable_bytes >= max_length
+            if @read_buffer.empty?
+              # Avoid allocating a new buffer string when the read buffer is empty
+              @read_buffer = @socket.read_nonblock(max_length, @read_buffer)
+            else
+              @read_buffer << @socket.read_nonblock(max_length - readable_bytes)
+            end
           end
         else
-          while !@backend_eof
-            @read_buffer << @socket.read_nonblock(@data[:chunk_size])
+          until @backend_eof
+            if @read_buffer.empty?
+              # Avoid allocating a new buffer string when the read buffer is empty
+              @read_buffer = @socket.read_nonblock(@data[:chunk_size], @read_buffer)
+            else
+              @read_buffer << @socket.read_nonblock(@data[:chunk_size])
+            end
           end
         end
       rescue OpenSSL::SSL::SSLError => error
@@ -220,18 +269,32 @@ module Excon
         @backend_eof = true
       end
 
-      ret = if max_length
+      if max_length
         if @read_buffer.empty?
-          nil # EOF met at beginning
+          # EOF met at beginning
+          @eof = @backend_eof
+          nil
         else
-          @read_buffer.slice!(0, max_length)
+          start = @read_offset
+
+          # Ensure that we can seek backwards when reading until a terminator string.
+          # The read offset must never point past the end of the read buffer.
+          @read_offset += max_length > readable_bytes ? readable_bytes : max_length
+          @read_buffer[start...@read_offset]
         end
       else
         # read until EOFError, so return everything
-        @read_buffer.slice!(0, @read_buffer.length)
+        start = @read_offset
+
+        @read_offset = @read_buffer.length
+        @eof = @backend_eof
+
+        @read_buffer[start..-1]
       end
-      @eof = @backend_eof && @read_buffer.empty?
-      ret
+    end
+
+    def readable_bytes
+      @read_buffer.length - @read_offset
     end
 
     def read_block(max_length)
@@ -294,17 +357,33 @@ module Excon
     end
 
     def select_with_timeout(socket, type)
+      timeout_kind = type
+      timeout = @data[OPERATION_TO_TIMEOUT[type]]
+
+      # Check whether the request has a timeout configured.
+      if @data.include?(:deadline)
+        request_timeout = request_time_remaining
+
+        # If the time remaining until the request times out is less than the timeout for the type of select,
+        # use the time remaining as the timeout instead.
+        if request_timeout < timeout
+          timeout_kind = :request
+          timeout = request_timeout
+        end
+      end
+
       select = case type
       when :connect_read
-        IO.select([socket], nil, nil, @data[:connect_timeout])
+        IO.select([socket], nil, nil, timeout)
       when :connect_write
-        IO.select(nil, [socket], nil, @data[:connect_timeout])
+        IO.select(nil, [socket], nil, timeout)
       when :read
-        IO.select([socket], nil, nil, @data[:read_timeout])
+        IO.select([socket], nil, nil, timeout)
       when :write
-        IO.select(nil, [socket], nil, @data[:write_timeout])
+        IO.select(nil, [socket], nil, timeout)
       end
-      select || raise(Excon::Errors::Timeout.new("#{type} timeout reached"))
+
+      select || raise(Excon::Errors::Timeout.new("#{timeout_kind} timeout reached"))
     end
 
     def unpacked_sockaddr
@@ -314,5 +393,16 @@ module Excon
         raise
       end
     end
+
+    # Returns the remaining time in seconds until we reach the deadline for the request timeout.
+    # Raises an exception if we have exceeded the request timeout's deadline.
+    def request_time_remaining
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      deadline = @data[:deadline]
+
+      raise(Excon::Errors::Timeout.new('request timeout reached')) if now >= deadline
+
+      deadline - now
+    end
   end
 end

data/lib/excon/ssl_socket.rb

@@ -108,7 +108,7 @@ module Excon
       end
 
       if @data[:proxy]
-        request = "CONNECT #{@data[:host]}#{port_string(@data.merge(:omit_default_port => false))}#{Excon::HTTP_1_1}" +
+        request = "CONNECT #{@data[:host]}#{Excon::HTTP_1_1}" \
                   "Host: #{@data[:host]}#{port_string(@data)}#{Excon::CR_NL}"
 
         if @data[:proxy].has_key?(:user) || @data[:proxy].has_key?(:password)

data/lib/excon/test/server.rb

@@ -42,7 +42,6 @@ module Excon
         if RUBY_PLATFORM == 'java'
           @pid, @write, @read, @error = IO.popen4(*args)
         else
-          GC.disable if RUBY_VERSION < '1.9'
           @pid, @write, @read, @error = Open4.popen4(*args)
         end
         @started_at = Time.now
@@ -57,7 +56,6 @@ module Excon
           Process.kill('USR1', pid)
         else
           Process.kill(9, pid)
-          GC.enable if RUBY_VERSION < '1.9'
           Process.wait(pid)
         end