excon 0.15.5 → 0.16.0

data/README.md

@@ -54,6 +54,12 @@ Both one-off and persistent connections support many other options. Here are a f
     connection.request(:method => :get)
     connection.request(:method => 'GET')
 
+    # this request can be repeated safely, so retry on errors up to 3 times
+    connection.request(:idempotent => true)
+
+    # opt out of nonblocking operations for performance and/or as a workaround
+    connection.request(:nonblock => false)
+
 These options can be combined to make pretty much any request you might need.
 
 Excon can also expect one or more HTTP status code in response, raising an exception if the response does not meet the criteria.

data/changelog.txt

@@ -1,3 +1,9 @@
+0.16.0 09/14/2012
+=================
+
+add nonblock => false to use blocking requests with Timeout.timeout
+update readme to describe nonblock and idempotent options
+
 0.15.5 08/01/2012
 =================
 

data/excon.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'excon'
-  s.version           = '0.15.5'
-  s.date              = '2012-08-01'
+  s.version           = '0.16.0'
+  s.date              = '2012-08-14'
   s.rubyforge_project = 'excon'
 
   ## Make sure your summary is short. The description may be as long

data/lib/excon.rb

@@ -6,6 +6,7 @@ require 'forwardable'
 require 'openssl'
 require 'rbconfig'
 require 'socket'
+require 'timeout'
 require 'uri'
 
 require 'excon/constants'
@@ -26,6 +27,7 @@ module Excon
         :headers            => {},
         :instrumentor_name  => 'excon',
         :mock               => false,
+        :nonblock           => true,
         :read_timeout       => 60,
         :retry_limit        => DEFAULT_RETRY_LIMIT,
         :ssl_ca_file        => DEFAULT_CA_FILE,

data/lib/excon/constants.rb

@@ -1,6 +1,6 @@
 module Excon
   unless const_defined?(:VERSION)
-    VERSION = '0.15.5'
+    VERSION = '0.16.0'
   end
 
   unless const_defined?(:CHUNK_SIZE)

data/lib/excon/socket.rb

@@ -33,7 +33,17 @@ module Excon
 
           socket = ::Socket.new(a_family, s_type, 0)
 
-          socket.connect_nonblock(sockaddr)
+          if @params[:nonblock]
+            socket.connect_nonblock(sockaddr)
+          else
+            begin
+              Timeout.timeout(@params[:connect_timeout]) do
+                socket.connect(sockaddr)
+              end
+            rescue Timeout::Error
+              raise Excon::Errors::Timeout.new('connect timeout reached')
+            end
+          end
 
           @socket = socket
           break
@@ -67,85 +77,106 @@ module Excon
 
     def read(max_length=nil)
       return nil if @eof
-
-      begin
-        if max_length
-          until @read_buffer.length >= max_length
-            @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
+      if @eof
+        nil
+      elsif @params[:nonblock]
+        begin
+          if max_length
+            until @read_buffer.length >= max_length
+              @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
+            end
+          else
+            while true
+              @read_buffer << @socket.read_nonblock(CHUNK_SIZE)
+            end
           end
-        else
-          while true
-            @read_buffer << @socket.read_nonblock(CHUNK_SIZE)
+        rescue OpenSSL::SSL::SSLError => error
+          if error.message == 'read would block'
+            if IO.select([@socket], nil, nil, @params[:read_timeout])
+              retry
+            else
+              raise(Excon::Errors::Timeout.new("read timeout reached"))
+            end
+          else
+            raise(error)
           end
-        end
-      rescue OpenSSL::SSL::SSLError => error
-        if error.message == 'read would block'
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
           if IO.select([@socket], nil, nil, @params[:read_timeout])
             retry
           else
             raise(Excon::Errors::Timeout.new("read timeout reached"))
           end
-        else
-          raise(error)
+        rescue EOFError
+          @eof = true
         end
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
-        if IO.select([@socket], nil, nil, @params[:read_timeout])
-          retry
+        if max_length
+          @read_buffer.slice!(0, max_length)
         else
-          raise(Excon::Errors::Timeout.new("read timeout reached"))
+          # read until EOFError, so return everything
+          @read_buffer.slice!(0, @read_buffer.length)
         end
-      rescue EOFError
-        @eof = true
-      end
-      if max_length
-        @read_buffer.slice!(0, max_length)
       else
-        # read until EOFError, so return everything
-        @read_buffer.slice!(0, @read_buffer.length)
+        begin
+          Timeout.timeout(@params[:read_timeout]) do
+            @socket.read(max_length)
+          end
+        rescue Timeout::Error
+          raise Excon::Errors::Timeout.new('read timeout reached')
+        end
       end
     end
 
     def write(data)
-      # 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
-      # in the wild, so this is a simple defensive mechanism)
-      while data
-        begin
-          # I wish that this API accepted a start position, then we wouldn't
-          # have to slice data when there is a short write.
-          written = @socket.write_nonblock(data)
-        rescue OpenSSL::SSL::SSLError => error
-          if error.message == 'write would block'
+      if @params[: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
+        # in the wild, so this is a simple defensive mechanism)
+        while data
+          begin
+            # I wish that this API accepted a start position, then we wouldn't
+            # have to slice data when there is a short write.
+            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])
+                retry
+              else
+                raise(Excon::Errors::Timeout.new("write timeout reached"))
+              end
+            else
+              raise(error)
+            end
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable
             if IO.select(nil, [@socket], nil, @params[:write_timeout])
               retry
             else
               raise(Excon::Errors::Timeout.new("write timeout reached"))
             end
           else
-            raise(error)
+            # Fast, common case.
+            # The >= seems weird, why would it have written MORE than we
+            # requested. But we're getting some weird behavior when @socket
+            # is an OpenSSL socket, where it seems like it's saying it wrote
+            # more (perhaps due to SSL packet overhead?).
+            #
+            # Pretty weird, but this is a simple defensive mechanism.
+            return if written >= data.size
+
+            # This takes advantage of the fact that most ruby implementations
+            # have Copy-On-Write strings. Thusly why requesting a subrange
+            # of data, we actually don't copy data because the new string
+            # simply references a subrange of the original.
+            data = data[written, data.size]
           end
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable
-          if IO.select(nil, [@socket], nil, @params[:write_timeout])
-            retry
-          else
-            raise(Excon::Errors::Timeout.new("write timeout reached"))
+        end
+      else
+        begin
+          Timeout.timeout(@params[:write_timeout]) do
+            @socket.write(data)
           end
-        else
-          # Fast, common case.
-          # The >= seems weird, why would it have written MORE than we
-          # requested. But we're getting some weird behavior when @socket
-          # is an OpenSSL socket, where it seems like it's saying it wrote
-          # more (perhaps due to SSL packet overhead?).
-          #
-          # Pretty weird, but this is a simple defensive mechanism.
-          return if written >= data.size
-
-          # This takes advantage of the fact that most ruby implementations
-          # have Copy-On-Write strings. Thusly why requesting a subrange
-          # of data, we actually don't copy data because the new string
-          # simply references a subrange of the original.
-          data = data[written, data.size]
+        rescue Timeout::Error
+          Excon::Errors::Timeout.new('write timeout reached')
         end
       end
     end

data/tests/test_helper.rb

@@ -6,123 +6,129 @@ Bundler.require(:default, :development)
 require 'stringio'
 
 def basic_tests(url = 'http://127.0.0.1:9292')
+  [false, true].each do |nonblock|
 
-  connection = Excon.new(url, :ssl_verify_peer => false)
+    connection = Excon.new(url, :nonblock => nonblock, :ssl_verify_peer => false)
 
-  tests('GET /content-length/100') do
-    response = connection.request(:method => :get, :path => '/content-length/100')
+    tests("nonblock => #{nonblock}") do
 
-    tests('response.status').returns(200) do
-      response.status
-    end
+      tests('GET /content-length/100') do
+        response = connection.request(:method => :get, :path => '/content-length/100')
 
-    tests("response.headers['Connection']").returns('Keep-Alive') do
-      response.headers['Connection']
-    end
+        tests('response.status').returns(200) do
+          response.status
+        end
 
-    tests("response.headers['Content-Length']").returns('100') do
-      response.headers['Content-Length']
-    end
+        tests("response.headers['Connection']").returns('Keep-Alive') do
+          response.headers['Connection']
+        end
 
-    tests("response.headers['Content-Type']").returns('text/html;charset=utf-8') do
-      response.headers['Content-Type']
-    end
+        tests("response.headers['Content-Length']").returns('100') do
+          response.headers['Content-Length']
+        end
 
-    test("Time.parse(response.headers['Date']).is_a?(Time)") do
-      Time.parse(response.headers['Date']).is_a?(Time)
-    end
+        tests("response.headers['Content-Type']").returns('text/html;charset=utf-8') do
+          response.headers['Content-Type']
+        end
 
-    test("!!(response.headers['Server'] =~ /^WEBrick/)") do
-      !!(response.headers['Server'] =~ /^WEBrick/)
-    end
+        test("Time.parse(response.headers['Date']).is_a?(Time)") do
+          Time.parse(response.headers['Date']).is_a?(Time)
+        end
 
-    tests("response.headers['Custom']").returns("Foo: bar") do
-      response.headers['Custom']
-    end
+        test("!!(response.headers['Server'] =~ /^WEBrick/)") do
+          !!(response.headers['Server'] =~ /^WEBrick/)
+        end
 
-    tests("response.body").returns('x' * 100) do
-      response.body
-    end
+        tests("response.headers['Custom']").returns("Foo: bar") do
+          response.headers['Custom']
+        end
 
-    tests("deprecated block usage").returns(['x' * 100, 0, 100]) do
-      data = []
-      connection.request(:method => :get, :path => '/content-length/100') do |chunk, remaining_length, total_length|
-        data = [chunk, remaining_length, total_length]
-      end
-      data
-    end
+        tests("response.body").returns('x' * 100) do
+          response.body
+        end
+
+        tests("deprecated block usage").returns(['x' * 100, 0, 100]) do
+          data = []
+          connection.request(:method => :get, :path => '/content-length/100') do |chunk, remaining_length, total_length|
+            data = [chunk, remaining_length, total_length]
+          end
+          data
+        end
+
+        tests("response_block usage").returns(['x' * 100, 0, 100]) do
+          data = []
+          response_block = lambda do |chunk, remaining_length, total_length|
+            data = [chunk, remaining_length, total_length]
+          end
+          connection.request(:method => :get, :path => '/content-length/100', :response_block => response_block)
+          data
+        end
 
-    tests("response_block usage").returns(['x' * 100, 0, 100]) do
-      data = []
-      response_block = lambda do |chunk, remaining_length, total_length|
-        data = [chunk, remaining_length, total_length]
       end
-      connection.request(:method => :get, :path => '/content-length/100', :response_block => response_block)
-      data
-    end
 
-  end
+      tests('POST /body-sink') do
 
-  tests('POST /body-sink') do
+        tests('response.body').returns("5000000") do
+          response = connection.request(:method => :post, :path => '/body-sink', :headers => { 'Content-Type' => 'text/plain' }, :body => 'x' * 5_000_000)
+          response.body
+        end
 
-    tests('response.body').returns("5000000") do
-      response = connection.request(:method => :post, :path => '/body-sink', :headers => { 'Content-Type' => 'text/plain' }, :body => 'x' * 5_000_000)
-      response.body
-    end
+        tests('empty body').returns('0') do
+          response = connection.request(:method => :post, :path => '/body-sink', :headers => { 'Content-Type' => 'text/plain' }, :body => '')
+          response.body
+        end
 
-    tests('empty body').returns('0') do
-      response = connection.request(:method => :post, :path => '/body-sink', :headers => { 'Content-Type' => 'text/plain' }, :body => '')
-      response.body
-    end
+      end
 
-  end
+      tests('POST /echo') do
 
-  tests('POST /echo') do
+        tests('with file').returns('x' * 100 + "\n") do
+          file_path = File.join(File.dirname(__FILE__), "data", "xs")
+          response = connection.request(:method => :post, :path => '/echo', :body => File.open(file_path))
+          response.body
+        end
 
-    tests('with file').returns('x' * 100 + "\n") do
-      file_path = File.join(File.dirname(__FILE__), "data", "xs")
-      response = connection.request(:method => :post, :path => '/echo', :body => File.open(file_path))
-      response.body
-    end
+        tests('without request_block').returns('x' * 100) do
+          response = connection.request(:method => :post, :path => '/echo', :body => 'x' * 100)
+          response.body
+        end
 
-    tests('without request_block').returns('x' * 100) do
-      response = connection.request(:method => :post, :path => '/echo', :body => 'x' * 100)
-      response.body
-    end
+        tests('with request_block').returns('x' * 100) do
+          data = ['x'] * 100
+          request_block = lambda do
+            data.shift.to_s
+          end
+          response = connection.request(:method => :post, :path => '/echo', :request_block => request_block)
+          response.body
+        end
 
-    tests('with request_block').returns('x' * 100) do
-      data = ['x'] * 100
-      request_block = lambda do
-        data.shift.to_s
       end
-      response = connection.request(:method => :post, :path => '/echo', :request_block => request_block)
-      response.body
-    end
 
-  end
+      tests('PUT /echo') do
 
-  tests('PUT /echo') do
+        tests('with file').returns('x' * 100 + "\n") do
+          file_path = File.join(File.dirname(__FILE__), "data", "xs")
+          response = connection.request(:method => :put, :path => '/echo', :body => File.open(file_path))
+          response.body
+        end
 
-    tests('with file').returns('x' * 100 + "\n") do
-      file_path = File.join(File.dirname(__FILE__), "data", "xs")
-      response = connection.request(:method => :put, :path => '/echo', :body => File.open(file_path))
-      response.body
-    end
+        tests('without request_block').returns('x' * 100) do
+          response = connection.request(:method => :put, :path => '/echo', :body => 'x' * 100)
+          response.body
+        end
 
-    tests('without request_block').returns('x' * 100) do
-      response = connection.request(:method => :put, :path => '/echo', :body => 'x' * 100)
-      response.body
-    end
+        tests('request_block usage').returns('x' * 100) do
+          data = ['x'] * 100
+          request_block = lambda do
+            data.shift.to_s
+          end
+          response = connection.request(:method => :put, :path => '/echo', :request_block => request_block)
+          response.body
+        end
 
-    tests('request_block usage').returns('x' * 100) do
-      data = ['x'] * 100
-      request_block = lambda do
-        data.shift.to_s
       end
-      response = connection.request(:method => :put, :path => '/echo', :request_block => request_block)
-      response.body
-    end
 
+    end
   end
 end
 

data/tests/timeout_tests.rb

@@ -1,10 +1,13 @@
 with_rackup('timeout.ru') do
   Shindo.tests('read should timeout') do
-    connection = Excon.new('http://127.0.0.1:9292')
+    [false, true].each do |nonblock|
 
-    tests('hits read_timeout').raises(Excon::Errors::Timeout) do
-      connection.request(:method => :get, :path => '/timeout', :read_timeout => 1)
-    end
+      connection = Excon.new('http://127.0.0.1:9292', :nonblock => nonblock)
+
+      tests("nonblock => #{nonblock} hits read_timeout").raises(Excon::Errors::Timeout) do
+        connection.request(:method => :get, :path => '/timeout', :read_timeout => 1)
+      end
 
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excon
 version: !ruby/object:Gem::Version
-  version: 0.15.5
+  version: 0.16.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,11 +11,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-01 00:00:00.000000000 Z
+date: 2012-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70157967898360 !ruby/object:Gem::Requirement
+  requirement: &70312939290540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -23,10 +23,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70157967898360
+  version_requirements: *70312939290540
 - !ruby/object:Gem::Dependency
   name: delorean
-  requirement: &70157967894540 !ruby/object:Gem::Requirement
+  requirement: &70312939288380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -34,10 +34,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70157967894540
+  version_requirements: *70312939288380
 - !ruby/object:Gem::Dependency
   name: open4
-  requirement: &70157967906920 !ruby/object:Gem::Requirement
+  requirement: &70312939286840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -45,10 +45,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70157967906920
+  version_requirements: *70312939286840
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70157967905100 !ruby/object:Gem::Requirement
+  requirement: &70312939351900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -56,10 +56,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70157967905100
+  version_requirements: *70312939351900
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70157967902880 !ruby/object:Gem::Requirement
+  requirement: &70312939349280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -67,10 +67,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70157967902880
+  version_requirements: *70312939349280
 - !ruby/object:Gem::Dependency
   name: shindo
-  requirement: &70157967902120 !ruby/object:Gem::Requirement
+  requirement: &70312939363220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -78,10 +78,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70157967902120
+  version_requirements: *70312939363220
 - !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: &70157967917600 !ruby/object:Gem::Requirement
+  requirement: &70312939360540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -89,7 +89,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70157967917600
+  version_requirements: *70312939360540
 description: EXtended http(s) CONnections
 email: geemus@gmail.com
 executables: []
@@ -168,7 +168,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3311072793664556069
+      hash: -2915309492516457660
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: