excon 0.16.10 → 0.17.0

data/lib/excon/constants.rb

@@ -21,7 +21,7 @@ module Excon
 
   HTTP_1_1 = " HTTP/1.1\r\n"
 
-  HTTP_VERBS = %w{connect delete get head options post put trace}
+  HTTP_VERBS = %w{connect delete get head options post put trace patch}
 
   HTTPS = 'https'
 
@@ -29,7 +29,7 @@ module Excon
 
   REDACTED = 'REDACTED'
 
-  VERSION = '0.16.10'
+  VERSION = '0.17.0'
 
   unless ::IO.const_defined?(:WaitReadable)
     class ::IO

data/lib/excon/errors.rb

@@ -121,6 +121,13 @@ module Excon
         504 => [Excon::Errors::GatewayTimeout, 'Gateway Timeout']
       }
       error, message = @errors[response.status] || [Excon::Errors::HTTPStatusError, 'Unknown']
+
+      # scrub authorization
+      if request[:headers].has_key?('Authorization')
+        request = request.dup
+        request[:headers] = request[:headers].dup
+        request[:headers]['Authorization'] = REDACTED
+      end
       error.new("Expected(#{request[:expects].inspect}) <=> Actual(#{response.status} #{message})\n  request => #{request.inspect}\n  response => #{response.inspect}", request, response)
     end
 

data/lib/excon/middlewares/expects.rb

@@ -0,0 +1,19 @@
+module Excon
+  module Middleware
+    class Expects
+      def initialize(app)
+        @app = app
+      end
+
+      def call(datum)
+        response_datum = @app.call(datum)
+
+        if datum.has_key?(:expects) && ![*datum[:expects]].include?(response_datum[:status])
+          raise(Excon::Errors.status_error(datum, Excon::Response.new(response_datum)))
+        else
+          response_datum
+        end
+      end
+    end
+  end
+end

data/lib/excon/middlewares/instrumentor.rb

@@ -0,0 +1,26 @@
+module Excon
+  module Middleware
+    class Instrumentor
+      def initialize(app)
+        @app = app
+      end
+
+      def call(datum)
+        if datum.has_key?(:instrumentor)
+          if datum[:retries_remaining] < datum[:retry_limit]
+            event_name = "#{datum[:instrumentor_name]}.retry"
+          else
+            event_name = "#{datum[:instrumentor_name]}.request"
+          end
+          response_datum = datum[:instrumentor].instrument(event_name, datum) do
+            @app.call(datum)
+          end
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.response", response_datum)
+          response_datum
+        else
+          @app.call(datum)
+        end
+      end
+    end
+  end
+end

data/lib/excon/response.rb

@@ -1,29 +1,41 @@
 module Excon
   class Response
 
-    attr_accessor :body, :headers, :status
+    attr_accessor :body, :headers, :status, :remote_ip
 
-    def attributes
+    def data
       {
-        :body     => body,
-        :headers  => headers,
-        :status   => status
+        :body      => body,
+        :headers   => headers,
+        :status    => status,
+        :remote_ip => remote_ip
       }
     end
 
-    def initialize(attrs={})
-      @body    = attrs[:body]    || ''
-      @headers = attrs[:headers] || {}
-      @status  = attrs[:status]
+    def params
+      $stderr.puts("Excon::Response#params is deprecated use Excon::Response#data instead (#{caller.first})")
+      data
     end
 
-    def self.parse(socket, params={})
-      response = new(:status => socket.read(12)[9, 11].to_i)
+    def initialize(params={})
+      @body      = params[:body]    || ''
+      @headers   = params[:headers] || {}
+      @status    = params[:status]
+      @remote_ip = params[:remote_ip]
+    end
+
+    def self.parse(socket, datum={})
+      response_datum = {
+        :body       => '',
+        :headers    => {},
+        :status     => socket.read(12)[9, 11].to_i,
+        :remote_ip  => socket.remote_ip
+      }
       socket.readline # read the rest of the status line and CRLF
 
       until ((data = socket.readline).chop!).empty?
         key, value = data.split(/:\s*/, 2)
-        response.headers[key] = ([*response.headers[key]] << value).compact.join(', ')
+        response_datum[:headers][key] = ([*response_datum[:headers][key]] << value).compact.join(', ')
         if key.casecmp('Content-Length') == 0
           content_length = value.to_i
         elsif (key.casecmp('Transfer-Encoding') == 0) && (value.casecmp('chunked') == 0)
@@ -31,47 +43,47 @@ module Excon
         end
       end
 
-      unless (['HEAD', 'CONNECT'].include?(params[:method].to_s.upcase)) || NO_ENTITY.include?(response.status)
+      unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(response_datum[:status])
 
         # check to see if expects was set and matched
-        expected_status = !params.has_key?(:expects) || [*params[:expects]].include?(response.status)
+        expected_status = !datum.has_key?(:expects) || [*datum[:expects]].include?(response_datum[:status])
 
         # if expects matched and there is a block, use it
-        if expected_status && params.has_key?(:response_block)
+        if expected_status && datum.has_key?(:response_block)
           if transfer_encoding_chunked
             # 2 == "/r/n".length
             while (chunk_size = socket.readline.chop!.to_i(16)) > 0
-              params[:response_block].call(socket.read(chunk_size + 2).chop!, nil, nil)
+              datum[:response_block].call(socket.read(chunk_size + 2).chop!, nil, nil)
             end
             socket.read(2)
           elsif remaining = content_length
             while remaining > 0
-              params[:response_block].call(socket.read([params[:chunk_size], remaining].min), [remaining - params[:chunk_size], 0].max, content_length)
-              remaining -= params[:chunk_size]
+              datum[:response_block].call(socket.read([datum[:chunk_size], remaining].min), [remaining - datum[:chunk_size], 0].max, content_length)
+              remaining -= datum[:chunk_size]
             end
           else
-            while remaining = socket.read(params[:chunk_size])
-              params[:response_block].call(remaining, remaining.length, content_length)
+            while remaining = socket.read(datum[:chunk_size])
+              datum[:response_block].call(remaining, remaining.length, content_length)
             end
           end
         else # no block or unexpected status
           if transfer_encoding_chunked
             while (chunk_size = socket.readline.chop!.to_i(16)) > 0
-              response.body << socket.read(chunk_size + 2).chop! # 2 == "/r/n".length
+              response_datum[:body] << socket.read(chunk_size + 2).chop! # 2 == "/r/n".length
             end
             socket.read(2) # 2 == "/r/n".length
           elsif remaining = content_length
             while remaining > 0
-              response.body << socket.read([params[:chunk_size], remaining].min)
-              remaining -= params[:chunk_size]
+              response_datum[:body] << socket.read([datum[:chunk_size], remaining].min)
+              remaining -= datum[:chunk_size]
             end
           else
-            response.body << socket.read
+            response_datum[:body] << socket.read
           end
         end
       end
 
-      response
+      response_datum
     end
 
     # Retrieve a specific header value. Header names are treated case-insensitively.

data/lib/excon/socket.rb

@@ -3,16 +3,32 @@ module Excon
 
     extend Forwardable
 
-    attr_accessor :params
+    attr_accessor :data
+
+    def params
+      $stderr.puts("Excon::Socket#params is deprecated use Excon::Socket#data instead (#{caller.first})")
+      @data
+    end
+    def params=(new_params)
+      $stderr.puts("Excon::Socket#params= is deprecated use Excon::Socket#data= instead (#{caller.first})")
+      @data = new_params
+    end
+
+    attr_reader :remote_ip
 
     def_delegators(:@socket, :close,    :close)
     def_delegators(:@socket, :readline, :readline)
 
-    def initialize(params = {}, proxy = nil)
-      @params, @proxy = params, proxy
+    def initialize(data = {})
+      @data = data
       @read_buffer = ''
       @eof = false
 
+      @data[:family] ||= ::Socket::Constants::AF_UNSPEC
+      if @data[:proxy]
+        @data[:proxy][:family]  ||= ::Socket::Constants::AF_UNSPEC
+      end
+
       connect
     end
 
@@ -20,24 +36,26 @@ module Excon
       @socket = nil
       exception = nil
 
-      addrinfo = if @proxy
-        ::Socket.getaddrinfo(@proxy[:host], @proxy[:port].to_i, ::Socket::Constants::AF_UNSPEC, ::Socket::Constants::SOCK_STREAM)
+      addrinfo = if @data[:proxy]
+        ::Socket.getaddrinfo(@data[:proxy][:host], @data[:proxy][:port], @data[:proxy][:family], ::Socket::Constants::SOCK_STREAM)
       else
-        ::Socket.getaddrinfo(@params[:host], @params[:port].to_i, ::Socket::Constants::AF_UNSPEC, ::Socket::Constants::SOCK_STREAM)
+        ::Socket.getaddrinfo(@data[:host], @data[:port], @data[:family], ::Socket::Constants::SOCK_STREAM)
       end
 
       addrinfo.each do |_, port, _, ip, a_family, s_type|
+        @remote_ip = ip
+
         # nonblocking connect
         begin
           sockaddr = ::Socket.sockaddr_in(port, ip)
 
           socket = ::Socket.new(a_family, s_type, 0)
 
-          if @params[:nonblock]
+          if @data[:nonblock]
             socket.connect_nonblock(sockaddr)
           else
             begin
-              Timeout.timeout(@params[:connect_timeout]) do
+              Timeout.timeout(@data[:connect_timeout]) do
                 socket.connect(sockaddr)
               end
             rescue Timeout::Error
@@ -48,7 +66,7 @@ module Excon
           @socket = socket
           break
         rescue Errno::EINPROGRESS
-          unless IO.select(nil, [socket], nil, @params[:connect_timeout])
+          unless IO.select(nil, [socket], nil, @data[:connect_timeout])
             raise(Excon::Errors::Timeout.new("connect timeout reached"))
           end
           begin
@@ -76,10 +94,9 @@ module Excon
     end
 
     def read(max_length=nil)
-      return nil if @eof
       if @eof
-        ''
-      elsif @params[:nonblock]
+        return nil
+      elsif @data[:nonblock]
         begin
           if max_length
             until @read_buffer.length >= max_length
@@ -87,12 +104,12 @@ module Excon
             end
           else
             while true
-              @read_buffer << @socket.read_nonblock(@params[:chunk_size])
+              @read_buffer << @socket.read_nonblock(@data[:chunk_size])
             end
           end
         rescue OpenSSL::SSL::SSLError => error
           if error.message == 'read would block'
-            if IO.select([@socket], nil, nil, @params[:read_timeout])
+            if IO.select([@socket], nil, nil, @data[:read_timeout])
               retry
             else
               raise(Excon::Errors::Timeout.new("read timeout reached"))
@@ -101,7 +118,7 @@ module Excon
             raise(error)
           end
         rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
-          if IO.select([@socket], nil, nil, @params[:read_timeout])
+          if IO.select([@socket], nil, nil, @data[:read_timeout])
             retry
           else
             raise(Excon::Errors::Timeout.new("read timeout reached"))
@@ -117,7 +134,7 @@ module Excon
         end
       else
         begin
-          Timeout.timeout(@params[:read_timeout]) do
+          Timeout.timeout(@data[:read_timeout]) do
             @socket.read(max_length)
           end
         rescue Timeout::Error
@@ -127,7 +144,7 @@ module Excon
     end
 
     def write(data)
-      if @params[:nonblock]
+      if @data[:nonblock]
         # We normally return from the return in the else block below, but
         # we guard that data is still something in case we get weird
         # values and String#[] returns nil. (This behavior has been observed
@@ -139,7 +156,7 @@ module Excon
             written = @socket.write_nonblock(data)
           rescue OpenSSL::SSL::SSLError => error
             if error.message == 'write would block'
-              if IO.select(nil, [@socket], nil, @params[:write_timeout])
+              if IO.select(nil, [@socket], nil, @data[:write_timeout])
                 retry
               else
                 raise(Excon::Errors::Timeout.new("write timeout reached"))
@@ -148,7 +165,7 @@ module Excon
               raise(error)
             end
           rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable
-            if IO.select(nil, [@socket], nil, @params[:write_timeout])
+            if IO.select(nil, [@socket], nil, @data[:write_timeout])
               retry
             else
               raise(Excon::Errors::Timeout.new("write timeout reached"))
@@ -172,7 +189,7 @@ module Excon
         end
       else
         begin
-          Timeout.timeout(@params[:write_timeout]) do
+          Timeout.timeout(@data[:write_timeout]) do
             @socket.write(data)
           end
         rescue Timeout::Error

data/lib/excon/ssl_socket.rb

@@ -1,8 +1,8 @@
 module Excon
   class SSLSocket < Socket
 
-    def initialize(params = {}, proxy = nil)
-      @params, @proxy = params, proxy
+    def initialize(data = {})
+      @data = data
       check_nonblock_support
 
       super
@@ -10,36 +10,31 @@ module Excon
       # create ssl context
       ssl_context = OpenSSL::SSL::SSLContext.new
 
-      if params[:ssl_verify_peer]
+      if @data[:ssl_verify_peer]
         # turn verification on
         ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
 
-        if params[:ssl_ca_path]
-          ssl_context.ca_path = params[:ssl_ca_path]
-        elsif params[:ssl_ca_file]
-          ssl_context.ca_file = params[:ssl_ca_file]
-        else
-          # use default cert store
-          store = OpenSSL::X509::Store.new
-          store.set_default_paths
-          ssl_context.cert_store = store
+        if @data[:ssl_ca_path]
+          ssl_context.ca_path = @data[:ssl_ca_path]
+        elsif @data[:ssl_ca_file]
+          ssl_context.ca_file = @data[:ssl_ca_file]
         end
       else
         # turn verification off
         ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
 
-      if @params.has_key?(:client_cert) && @params.has_key?(:client_key)
-        ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(@params[:client_cert]))
-        ssl_context.key = OpenSSL::PKey::RSA.new(File.read(@params[:client_key]))
+      if @data.has_key?(:client_cert) && @data.has_key?(:client_key)
+        ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(@data[:client_cert]))
+        ssl_context.key = OpenSSL::PKey::RSA.new(File.read(@data[:client_key]))
       end
 
-      if @proxy
-        request = 'CONNECT ' << @params[:host_port] << Excon::HTTP_1_1
-        request << 'Host: ' << @params[:host_port] << Excon::CR_NL
+      if @data[:proxy]
+        request = 'CONNECT ' << @data[:host_port] << Excon::HTTP_1_1
+        request << 'Host: ' << @data[:host_port] << Excon::CR_NL
 
-        if @proxy[:password] || @proxy[:user]
-          auth = ['' << @proxy[:user].to_s << ':' << @proxy[:password].to_s].pack('m').delete(Excon::CR_NL)
+        if @data[:proxy][:password] || @data[:proxy][:user]
+          auth = ['' << @data[:proxy][:user].to_s << ':' << @data[:proxy][:password].to_s].pack('m').delete(Excon::CR_NL)
           request << "Proxy-Authorization: Basic " << auth << Excon::CR_NL
         end
 
@@ -61,12 +56,12 @@ module Excon
 
       # Server Name Indication (SNI) RFC 3546
       if @socket.respond_to?(:hostname=)
-        @socket.hostname = @params[:host]
+        @socket.hostname = @data[:host]
       end
 
       # verify connection
-      if params[:ssl_verify_peer]
-        @socket.post_connection_check(@params[:host])
+      if @data[:ssl_verify_peer]
+        @socket.post_connection_check(@data[:host])
       end
 
       @socket
@@ -91,9 +86,9 @@ module Excon
 
     def check_nonblock_support
       # backwards compatability for things lacking nonblock
-      if !DEFAULT_NONBLOCK && params[:nonblock]
+      if !DEFAULT_NONBLOCK && @data[:nonblock]
         $stderr.puts("Excon nonblock is not supported by your OpenSSL::SSL::SSLSocket")
-        params[:nonblock] = false
+        @data[:nonblock] = false
       end
     end
 

data/lib/excon/standard_instrumentor.rb

@@ -6,7 +6,7 @@ module Excon
         params[:headers] = params[:headers].dup
         params[:headers]['Authorization'] = REDACTED
       end
-      $stderr.puts("#{name}  #{params}")
+      $stderr.puts("#{name}  #{params.inspect}")
       if block_given?
         yield
       end

data/tests/authorization_header_tests.rb

@@ -12,7 +12,7 @@ with_rackup('basic_auth.ru') do
       end
 
       test("authorization header remains correct for #{desc}") do
-        conn.connection[:headers]['Authorization'] == auth_header
+        conn.data[:headers]['Authorization'] == auth_header
       end
 
     end