excon 0.62.0 → 0.63.0

data/lib/excon/middlewares/instrumentor.rb

@@ -2,6 +2,14 @@
 module Excon
   module Middleware
     class Instrumentor < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :logger,
+          :instrumentor,
+          :instrumentor_name
+        ]
+      end
+
       def error_call(datum)
         if datum.has_key?(:instrumentor)
           datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.error", :error => datum[:error]) do

data/lib/excon/middlewares/mock.rb

@@ -2,6 +2,14 @@
 module Excon
   module Middleware
     class Mock < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :allow_unstubbed_requests,
+          :captures,
+          :mock
+        ]
+      end
+
       def request_call(datum)
         if datum[:mock]
           # convert File/Tempfile body to string before matching:

data/lib/excon/middlewares/response_parser.rb

@@ -6,6 +6,9 @@ module Excon
         unless datum.has_key?(:response)
           datum = Excon::Response.parse(datum[:connection].send(:socket), datum)
         end
+        if datum.has_key?(:logger)
+          datum[:response][:logger] = datum[:logger]
+        end
         @stack.response_call(datum)
       end
     end

data/lib/excon/pretty_printer.rb

@@ -9,14 +9,7 @@ module Excon
         datum.delete(:connection)
         datum.delete(:stack)
 
-        if datum.has_key?(:headers) && datum[:headers].has_key?('Authorization')
-          datum[:headers] = datum[:headers].dup
-          datum[:headers]['Authorization'] = REDACTED
-        end
-
-        if datum.has_key?(:password)
-          datum[:password] = REDACTED
-        end
+        datum = Utils.redact(datum)
       end
 
       indent += 2

data/lib/excon/socket.rb

@@ -7,6 +7,23 @@ module Excon
 
     attr_accessor :data
 
+    # read/write drawn from https://github.com/ruby-amqp/bunny/commit/75d9dd79551b31a5dd3d1254c537bad471f108cf
+    CONNECT_RETRY_EXCEPTION_CLASSES = if defined?(IO::EINPROGRESSWaitWritable) # Ruby >= 2.1
+      [Errno::EINPROGRESS, IO::EINPROGRESSWaitWritable]
+    else # Ruby <= 2.0
+      [Errno::EINPROGRESS]
+    end
+    READ_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitReadable) # Ruby >= 2.1
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable, IO::EAGAINWaitReadable, IO::EWOULDBLOCKWaitReadable]
+    else # Ruby <= 2.0
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable]
+    end
+    WRITE_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitWritable) # Ruby >= 2.1
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable, IO::EAGAINWaitWritable, IO::EWOULDBLOCKWaitWritable]
+    else # Ruby <= 2.0
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
+    end
+
     def params
       Excon.display_warning('Excon::Socket#params is deprecated use Excon::Socket#data instead.')
       @data
@@ -46,7 +63,7 @@ module Excon
       begin
         buffer << @socket.read_nonblock(1) while buffer[-1] != "\n"
         buffer
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+      rescue *READ_RETRY_EXCEPTION_CLASSES
         select_with_timeout(@socket, :read) && retry
       rescue OpenSSL::SSL::SSLError => error
         if error.message == 'read would block'
@@ -106,7 +123,7 @@ module Excon
         if @socket
           break
         end
-        
+
         @remote_ip = ip
 
         # nonblocking connect
@@ -128,7 +145,7 @@ module Excon
             socket.connect(sockaddr)
           end
           @socket = socket
-        rescue Errno::EINPROGRESS
+        rescue *CONNECT_RETRY_EXCEPTION_CLASSES
           select_with_timeout(socket, :connect_write)
           begin
             socket.connect_nonblock(sockaddr)
@@ -151,6 +168,17 @@ module Excon
                            ::Socket::TCP_NODELAY,
                            true)
       end
+
+      if @data[:keepalive]
+        if [:SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all?{|c| ::Socket.const_defined? c}
+          @socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+          @socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPIDLE, @data[:keepalive][:time])
+          @socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPINTVL, @data[:keepalive][:intvl])
+          @socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPCNT, @data[:keepalive][:probes])
+        else
+          Excon.display_warning('Excon::Socket keepalive was set, but is not supported by Ruby version.')
+        end
+      end
     end
 
     def read_nonblock(max_length)
@@ -170,7 +198,7 @@ module Excon
         else
           raise(error)
         end
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+      rescue *READ_RETRY_EXCEPTION_CLASSES
         if @read_buffer.empty?
           # if we didn't read anything, try again...
           select_with_timeout(@socket, :read) && retry
@@ -199,7 +227,7 @@ module Excon
       else
         raise(error)
       end
-    rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+    rescue *READ_RETRY_EXCEPTION_CLASSES
       if @read_buffer.empty?
         select_with_timeout(@socket, :read) && retry
       end
@@ -208,9 +236,7 @@ module Excon
     end
 
     def write_nonblock(data)
-      if FORCE_ENC
-        data.force_encoding('BINARY')
-      end
+      binary_encode(data)
       loop do
         written = nil
         begin
@@ -225,7 +251,7 @@ module Excon
           else
             raise error
           end
-        rescue OpenSSL::SSL::SSLError, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable => error
+        rescue OpenSSL::SSL::SSLError, *WRITE_RETRY_EXCEPTION_CLASSES => error
           if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
             raise error
           else
@@ -246,7 +272,7 @@ module Excon
 
     def write_block(data)
       @socket.write(data)
-    rescue OpenSSL::SSL::SSLError, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable => error
+    rescue OpenSSL::SSL::SSLError, *WRITE_RETRY_EXCEPTION_CLASSES => error
       if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
         raise error
       else

data/lib/excon/ssl_socket.rb

@@ -27,6 +27,13 @@ module Excon
       if @data[:ssl_version]
         ssl_context.ssl_version = @data[:ssl_version]
       end
+      if @data[:ssl_min_version]
+        ssl_context.min_version = @data[:ssl_min_version]
+      end
+      if @data[:ssl_max_version]
+        ssl_context.max_version = @data[:ssl_max_version]
+      end
+
 
       if @data[:ssl_verify_peer]
         # turn verification on

data/lib/excon/utils.rb

@@ -10,6 +10,12 @@ module Excon
     UNESCAPED = /([#{ Regexp.escape(CONTROL + ' ' + DELIMS + UNWISE + NONASCII) }])/
     ESCAPED   = /%([0-9a-fA-F]{2})/
 
+    def binary_encode(string)
+      if FORCE_ENC && string.encoding != Encoding::ASCII_8BIT
+        string.force_encoding('BINARY')
+      end
+    end
+
     def connection_uri(datum = @data)
       unless datum
         raise ArgumentError, '`datum` must be given unless called on a Connection'
@@ -21,6 +27,19 @@ module Excon
       end
     end
 
+    # Redact sensitive info from provided data
+    def redact(datum)
+      datum = datum.dup
+      if datum.has_key?(:headers) && datum[:headers].has_key?('Authorization')
+        datum[:headers] = datum[:headers].dup
+        datum[:headers]['Authorization'] = REDACTED
+      end
+      if datum.has_key?(:password)
+        datum[:password] = REDACTED
+      end
+      datum
+    end
+
     def request_uri(datum)
       connection_uri(datum) + datum[:path] + query_string(datum)
     end
@@ -59,7 +78,7 @@ module Excon
     def split_header_value(str)
       return [] if str.nil?
       str = str.dup.strip
-      str.force_encoding('BINARY') if FORCE_ENC
+      binary_encode(str)
       str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",]+)+)
                     (?:,\s*|\Z)'xn).flatten
     end
@@ -67,21 +86,21 @@ module Excon
     # Escapes HTTP reserved and unwise characters in +str+
     def escape_uri(str)
       str = str.dup
-      str.force_encoding('BINARY') if FORCE_ENC
+      binary_encode(str)
       str.gsub(UNESCAPED) { "%%%02X" % $1[0].ord }
     end
 
     # Unescapes HTTP reserved and unwise characters in +str+
     def unescape_uri(str)
       str = str.dup
-      str.force_encoding('BINARY') if FORCE_ENC
+      binary_encode(str)
       str.gsub(ESCAPED) { $1.hex.chr }
     end
 
     # Unescape form encoded values in +str+
     def unescape_form(str)
       str = str.dup
-      str.force_encoding('BINARY') if FORCE_ENC
+      binary_encode(str)
       str.gsub!(/\+/, ' ')
       str.gsub(ESCAPED) { $1.hex.chr }
     end

data/lib/excon/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Excon
-  VERSION = '0.62.0'
+  VERSION = '0.63.0'
 end

data/spec/excon/test/server_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Excon::Test::Server do
-  
+
   context 'when the web server is webrick' do
     it_should_behave_like "a excon test server", :webrick, 'basic.ru'
   end
@@ -23,6 +23,6 @@ describe Excon::Test::Server do
   end
 
   context 'when the web server is a executable' do
-    it_should_behave_like "a excon test server", :exec, 'good.rb'
+    it_should_behave_like "a excon test server", :exec, 'good_ipv4.rb'
   end
 end

data/spec/helpers/warning_helpers.rb

@@ -0,0 +1,9 @@
+def silence_warnings
+  orig_verbose = $VERBOSE
+  $VERBOSE = nil
+  Excon.set_raise_on_warnings!(false)
+  yield
+ensure
+  $VERBOSE = orig_verbose
+  Excon.set_raise_on_warnings!(true)
+end

data/spec/requests/unix_socket_spec.rb

@@ -1,25 +1,17 @@
 require "spec_helper"
 
 describe Excon::Connection do
+  include_context('stubs')
   context "when speaking to a UNIX socket" do
     context "Host header handling" do
       before do
-        responder = ->(req) do
+        Excon.stub do |req|
           {
             body: req[:headers].to_json,
             status: 200,
           }
         end
-
-        @original_mock = Excon.defaults[:mock]
-        Excon.defaults[:mock] = true
-        Excon.stub({}, responder)
-      end
-
-      after do
-        Excon.defaults[:mock] = @original_mock
       end
-
       it "sends an empty Host= by default" do
         conn = Excon::Connection.new(
           scheme: "unix",

data/spec/requests/validation_spec.rb

@@ -0,0 +1,80 @@
+describe Excon::Connection do
+  include_context('stubs')
+  describe 'validating parameters' do
+    class FooMiddleware < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [:foo]
+      end
+    end
+
+    let(:foo_stack) do
+      Excon.defaults[:middlewares] + [FooMiddleware]
+    end
+
+    def expect_parameter_warning(validation, key)
+      expect { yield }.to raise_error(Excon::Error::Warning, "Invalid Excon #{validation} keys: #{key.inspect}")
+    end
+
+    context 'with default middleware' do
+      it 'Connection.new warns on invalid parameter keys' do
+        expect_parameter_warning('connection', :foo) do
+          Excon.new('http://foo', :foo => :bar)
+        end
+      end
+
+      it 'Connection#request warns on invalid parameter keys' do
+        conn = Excon.new('http://foo')
+        expect_parameter_warning('request', :foo) do
+          conn.request(:foo => :bar)
+        end
+      end
+    end
+
+    context 'with custom middleware at instantiation' do
+      it 'Connection.new accepts parameters that are valid for the provided middleware' do
+        Excon.new('http://foo', :foo => :bar, :middlewares => foo_stack)
+      end
+
+      it 'Connection.new warns on parameters that are not valid for the provided middleware' do
+        expect_parameter_warning('connection', :bar) do
+          Excon.new('http://foo', :bar => :baz, :middlewares => foo_stack)
+        end
+      end
+
+      it 'Connection#request accepts parameters that are valid for the provided middleware' do
+        Excon.stub({}, {})
+        conn = Excon.new('http://foo', :middlewares => foo_stack)
+        conn.request(:foo => :bar)
+      end
+
+      it 'Connection#request warns on parameters that are not valid for the provided middleware' do
+        conn = Excon.new('http://foo', :middlewares => foo_stack)
+        expect_parameter_warning('request', :bar) do
+          conn.request(:bar => :baz)
+        end
+      end
+    end
+
+    context 'with custom middleware at request time' do
+      it 'Connection#request accepts parameters that are valid for the provided middleware' do
+        Excon.stub({}, {})
+        conn = Excon.new('http://foo')
+        conn.request(:foo => :bar, :middlewares => foo_stack)
+      end
+
+      it 'Connection#request warns on parameters that are not valid for the request middleware' do
+        conn = Excon.new('http://foo')
+        expect_parameter_warning('request', :bar) do
+          conn.request(:bar => :baz, :middlewares => foo_stack)
+        end
+      end
+
+      it 'Connection#request warns on parameters from instantiation that are not valid for the request middleware' do
+        conn = Excon.new('http://foo', :foo => :bar, :middlewares => foo_stack)
+        expect_parameter_warning('connection', :foo) do
+          conn.request(:middlewares => Excon.defaults[:middlewares])
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -15,6 +15,8 @@ RSpec.configure do |config|
   if config.files_to_run.one?
     config.default_formatter = 'doc'
   end
+
+  Excon.set_raise_on_warnings!(true)
 end
 
 # Load helpers

data/spec/support/shared_contexts/test_stub_context.rb

@@ -0,0 +1,11 @@
+shared_context "stubs" do 
+  before do
+    @original_mock = Excon.defaults[:mock]
+    Excon.defaults[:mock] = true
+  end
+
+  after do
+    Excon.defaults[:mock] = @original_mock
+    Excon.stubs.clear
+  end
+end

data/spec/support/shared_examples/shared_example_for_clients.rb

@@ -91,8 +91,10 @@ shared_examples_for 'a basic client' do |url = 'http://127.0.0.1:9292', opts = {
             data = []
             it 'yields with a chunk, remaining length, and total length' do
               expect do
-                conn.request(method: :get, path: '/content-length/100') do |chunk, remaining_length, total_length|
-                  data = [chunk, remaining_length, total_length]
+                silence_warnings do
+                  conn.request(method: :get, path: '/content-length/100') do |chunk, remaining_length, total_length|
+                    data = [chunk, remaining_length, total_length]
+                  end
                 end
               end.to_not raise_error
             end
@@ -163,8 +165,8 @@ shared_examples_for 'a basic client' do |url = 'http://127.0.0.1:9292', opts = {
             end
 
             context 'when a string is the body paramter' do
-              it 'does not change the econding of the body' do
-                skip unless RUBY_VERSION >= '1.9'
+              it 'does not change the enconding of the body' do
+                skip unless RUBY_VERSION >= '2.0'
 
                 string_body = '¥£€'
                 expect do

data/tests/authorization_header_tests.rb

@@ -1,29 +1,27 @@
 Shindo.tests('Excon basics (Authorization data redacted)') do
-  with_rackup('basic_auth.ru') do
-    cases = [
-      ['user & pass', 'http://user1:pass1@foo.com/', 'Basic dXNlcjE6cGFzczE='],
-      ['email & pass', 'http://foo%40bar.com:pass1@foo.com/', 'Basic Zm9vQGJhci5jb206cGFzczE='],
-      ['user no pass', 'http://three_user@foo.com/', 'Basic dGhyZWVfdXNlcjo='],
-      ['pass no user', 'http://:derppass@foo.com/', 'Basic OmRlcnBwYXNz']
-    ]
-    cases.each do |desc,url,auth_header|
-      conn = nil
+  cases = [
+    ['user & pass', 'http://user1:pass1@foo.com/', 'Basic dXNlcjE6cGFzczE='],
+    ['email & pass', 'http://foo%40bar.com:pass1@foo.com/', 'Basic Zm9vQGJhci5jb206cGFzczE='],
+    ['user no pass', 'http://three_user@foo.com/', 'Basic dGhyZWVfdXNlcjo='],
+    ['pass no user', 'http://:derppass@foo.com/', 'Basic OmRlcnBwYXNz']
+  ]
+  cases.each do |desc,url,auth_header|
+    conn = nil
 
-      test("authorization header concealed for #{desc}") do
-        conn = Excon.new(url)
-        !conn.inspect.include?(auth_header)
-      end
-
-      if conn.data[:password]
-        test("password param concealed for #{desc}") do
-          !conn.inspect.include?(conn.data[:password])
-        end
-      end
+    test("authorization header concealed for #{desc}") do
+      conn = Excon.new(url)
+      !conn.inspect.include?(auth_header)
+    end
 
-      test("password param remains correct for #{desc}") do
-        conn.data[:password] == URI.parse(url).password
+    if conn.data[:password]
+      test("password param concealed for #{desc}") do
+        !conn.inspect.include?(conn.data[:password])
       end
+    end
 
+    test("password param remains correct for #{desc}") do
+      conn.data[:password] == URI.parse(url).password
     end
+
   end
 end