excon 0.99.0 → 1.2.5

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
@@ -160,7 +181,7 @@ module Excon
             socket.close rescue nil
           end
         rescue SystemCallError => exception
-          socket.close rescue nil if socket
+          socket&.close rescue nil
         end
       end
 
@@ -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

@@ -26,6 +26,7 @@ module Excon
       if defined?(OpenSSL::SSL::OP_NO_COMPRESSION)
         ssl_context_options |= OpenSSL::SSL::OP_NO_COMPRESSION
       end
+      ssl_context_options |= OpenSSL::SSL::OP_IGNORE_UNEXPECTED_EOF if @data[:ignore_unexpected_eof]
       ssl_context.options = ssl_context_options
 
       ssl_context.ciphers = @data[:ciphers]
@@ -63,7 +64,7 @@ module Excon
         unless ca_file || ca_path || cert_store
           # workaround issue #257 (JRUBY-6970)
           ca_file = DEFAULT_CA_FILE
-          ca_file = ca_file.gsub(/^jar:/, '') if ca_file =~ /^jar:file:\//
+          ca_file = ca_file.gsub(/^jar:/, '') if ca_file.match?(/^jar:file:\//)
 
           begin
             ssl_context.cert_store.add_file(ca_file)
@@ -108,7 +109,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]}#{port_string(@data)}#{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/plugin/server/puma.rb

@@ -7,7 +7,7 @@ module Excon
             open_process(RbConfig.ruby, '-S', 'puma', '-b', bind_uri.to_s, app_str)
             process_stderr = ""
             line = ''
-            until line =~ /Use Ctrl-C to stop/
+            until line.include?('Use Ctrl-C to stop')
               line = read.gets
               raise process_stderr if line.nil?
               process_stderr << line

data/lib/excon/test/plugin/server/unicorn.rb

@@ -12,19 +12,19 @@ module Excon
               host = bind_uri.host.gsub(/[\[\]]/, '')
               bind_str = "#{host}:#{bind_uri.port}"
             end
-            args = [ 
+            args = [
               RbConfig.ruby,
               '-S',
-              'unicorn', 
-              '--no-default-middleware', 
+              'unicorn',
+              '--no-default-middleware',
               '-l',
-              bind_str,  
+              bind_str,
               app_str
             ]
             open_process(*args)
             process_stderr = ''
             line = ''
-            until line =~ /worker\=0 ready/
+            until line.include?('worker=0 ready')
               line = error.gets
               raise process_stderr if line.nil?
               process_stderr << line

data/lib/excon/test/plugin/server/webrick.rb

@@ -10,7 +10,7 @@ module Excon
             open_process(RbConfig.ruby, '-S', 'rackup', '-s', 'webrick', '--host', host, '--port', port, app_str)
             process_stderr = ""
             line = ''
-            until line =~ /HTTPServer#start/
+            until line.include?('HTTPServer#start')
               line = error.gets
               raise process_stderr if line.nil?
               process_stderr << line

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
 
@@ -75,7 +73,7 @@ module Excon
         while (line = lines.shift)
           case line
             when /(ERROR|Error)/
-              unless line =~ /(null cert chain|did not return a certificate|SSL_read:: internal error)/
+              unless line.match?(/(null cert chain|did not return a certificate|SSL_read:: internal error)/)
                 in_err = true
                 puts
               end

data/lib/excon/unix_socket.rb

@@ -34,7 +34,7 @@ module Excon
       end
 
     rescue => error
-      @socket.close rescue nil if @socket
+      @socket&.close rescue nil
       raise error
     end
 

data/lib/excon/utils.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
+
 module Excon
   module Utils
-    extend self
+    module_function
 
-    CONTROL   = (0x0..0x1f).map {|c| c.chr }.join + "\x7f"
+    CONTROL   = "#{(0x0..0x1f).map(&:chr).join}\u007F"
     DELIMS    = '<>#%"'
     UNWISE    = '{}|\\^[]`'
-    NONASCII  = (0x80..0xff).map {|c| c.chr }.join
-    UNESCAPED = /([#{ Regexp.escape(CONTROL + ' ' + DELIMS + UNWISE + NONASCII) }])/
-    ESCAPED   = /%([0-9a-fA-F]{2})/
+    NONASCII  = (0x80..0xff).map(&:chr).join
+    UNESCAPED = /([#{Regexp.escape("#{CONTROL} #{DELIMS}#{UNWISE}#{NONASCII}")}])/.freeze
+    ESCAPED   = /%([0-9a-fA-F]{2})/.freeze
 
     def binary_encode(string)
       if FORCE_ENC && string.encoding != Encoding::ASCII_8BIT
@@ -23,9 +24,8 @@ module Excon
     end
 
     def connection_uri(datum = @data)
-      unless datum
-        raise ArgumentError, '`datum` must be given unless called on a Connection'
-      end
+      raise ArgumentError, '`datum` must be given unless called on a Connection' unless datum
+
       if datum[:scheme] == UNIX
         "#{datum[:scheme]}://#{datum[:socket]}"
       else
@@ -36,21 +36,15 @@ module Excon
     # Redact sensitive info from provided data
     def redact(datum)
       datum = datum.dup
-      if datum.has_key?(:headers)
-        if datum[:headers].has_key?('Authorization') || datum[:headers].has_key?('Proxy-Authorization')
+      if datum.key?(:headers)
+        if datum[:headers].key?('Authorization') || datum[:headers].key?('Proxy-Authorization')
           datum[:headers] = datum[:headers].dup
         end
-        if datum[:headers].has_key?('Authorization')
-          datum[:headers]['Authorization'] = REDACTED
-        end
-        if datum[:headers].has_key?('Proxy-Authorization')
-          datum[:headers]['Proxy-Authorization'] = REDACTED
-        end
-      end
-      if datum.has_key?(:password)
-        datum[:password] = REDACTED
+        datum[:headers]['Authorization'] = REDACTED if datum[:headers].key?('Authorization')
+        datum[:headers]['Proxy-Authorization'] = REDACTED if datum[:headers].key?('Proxy-Authorization')
       end
-      if datum.has_key?(:proxy) && datum[:proxy] && datum[:proxy].has_key?(:password)
+      datum[:password] = REDACTED if datum.key?(:password)
+      if datum.key?(:proxy) && datum[:proxy]&.key?(:password)
         datum[:proxy] = datum[:proxy].dup
         datum[:proxy][:password] = REDACTED
       end
@@ -62,21 +56,27 @@ module Excon
     end
 
     def port_string(datum)
-      if datum[:port].nil? || (datum[:omit_default_port] && ((datum[:scheme].casecmp('http') == 0 && datum[:port] == 80) || (datum[:scheme].casecmp('https') == 0 && datum[:port] == 443)))
-        ''
+      if !default_port?(datum) || datum[:include_default_port] || !datum[:omit_default_port]
+        ":#{datum[:port]}"
       else
-        ':' + datum[:port].to_s
+        ''
       end
     end
 
+    def default_port?(datum)
+      (!datum[:scheme]&.casecmp?('unix') && datum[:port].nil?) ||
+        (datum[:scheme]&.casecmp?('http') && datum[:port] == 80) ||
+        (datum[:scheme]&.casecmp?('https') && datum[:port] == 443)
+    end
+
     def query_string(datum)
-      str = String.new
+      str = +''
       case datum[:query]
       when String
         str << '?' << datum[:query]
       when Hash
         str << '?'
-        datum[:query].sort_by {|k,_| k.to_s }.each do |key, values|
+        datum[:query].sort_by { |k, _| k.to_s }.each do |key, values|
           key = CGI.escape(key.to_s)
           if values.nil?
             str << key << '&'
@@ -94,46 +94,49 @@ module Excon
     # Splits a header value +str+ according to HTTP specification.
     def split_header_value(str)
       return [] if str.nil?
+
       str = str.dup.strip
       str = binary_encode(str)
-      str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",])+)
-                    (?:,\s*|\Z)'xn).flatten
+      str.scan(/\G((?:"(?:\\.|[^"])+?"|[^",])+)
+                    (?:,\s*|\Z)/xn).flatten
     end
 
     # Escapes HTTP reserved and unwise characters in +str+
     def escape_uri(str)
       str = str.dup
       str = binary_encode(str)
-      str.gsub(UNESCAPED) { "%%%02X" % $1[0].ord }
+      str.gsub(UNESCAPED) { format('%%%02X', ::Regexp.last_match(1)[0].ord) }
     end
 
     # Unescapes HTTP reserved and unwise characters in +str+
     def unescape_uri(str)
       str = str.dup
       str = binary_encode(str)
-      str.gsub(ESCAPED) { $1.hex.chr }
+      str.gsub(ESCAPED) { ::Regexp.last_match(1).hex.chr }
     end
 
     # Unescape form encoded values in +str+
     def unescape_form(str)
       str = str.dup
       str = binary_encode(str)
-      str.gsub!(/\+/, ' ')
-      str.gsub(ESCAPED) { $1.hex.chr }
+      str.tr!('+', ' ')
+      str.gsub(ESCAPED) { ::Regexp.last_match(1).hex.chr }
     end
 
     # Performs validation on the passed header hash and returns a string representation of the headers
     def headers_hash_to_s(headers)
-      headers_str = String.new
+      headers_str = +''
       headers.each do |key, values|
-        if key.to_s.match(/[\r\n]/)
-          raise Excon::Errors::InvalidHeaderKey.new(key.to_s.inspect + ' contains forbidden "\r" or "\n"')
+        if key.to_s.match?(/[\r\n]/)
+          raise Excon::Errors::InvalidHeaderKey, "#{key.to_s.inspect} contains forbidden \"\\r\" or \"\\n\""
         end
+
         [values].flatten.each do |value|
-          if value.to_s.match(/[\r\n]/)
+          if value.to_s.match?(/[\r\n]/)
             # Don't include the potentially sensitive header value (i.e. authorization token) in the message
-            raise Excon::Errors::InvalidHeaderValue.new(key.to_s + ' header value contains forbidden "\r" or "\n"')
+            raise Excon::Errors::InvalidHeaderValue, "#{key} header value contains forbidden \"\\r\" or \"\\n\""
           end
+
           headers_str << key.to_s << ': ' << value.to_s << CR_NL
         end
       end

data/lib/excon/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Excon
-  VERSION = '0.99.0'
+  VERSION = '1.2.5'
 end