typhoeus 0.6.9 → 0.7.0.pre1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmYzNGMzZmI1NzgwZjM4MjE3Mjc3OTkxMzkzZDQ4NWI1MmViZGQ4OQ==
+    NzFhNDA4NzIxZjBjODEyOGU0NGM3MGU4Y2E3NzRjMmRlNDg2YTY0Mg==
   data.tar.gz: !binary |-
-    YTVlMWVhYjBjYzczYTgyYWUzN2E3NDNiM2Y0ZTc2YjViNDZmMzUyYw==
+    MWQwYWI4Yjk0ZDM0MWY0ZGE0Y2JmMTQ1NjJhNzRiY2M3MmJhNDM2OQ==
 SHA512:
   metadata.gz: !binary |-
-    M2MwNzI3MmM3NmE0OGU3OGQ3OTY2OThmOGQ4ZDFiNzU2ZDU4NGYyYTFhM2Y1
-    ZGZiNTUwNjFhYjlmMTJjM2QwY2ZjNjlkZDkwOTRjYzIxOWNkMzA0YzZhMWY4
-    ZThjYzEzZDIzMDRhODU1NmU5NDFmMTQwNDQ3MmQxNWY3YThjNGM=
+    MDZlYmY3MmVlN2U3YTFkOGYxODU4MGYyMzE1NTZjMzViNWY2NTc2YWEzMTQy
+    NDhlYzE3N2I4MDM5NTYzY2JkMWNmYmI4MmNhNjg3ZjZmMmVlNGZmYWJkNGU2
+    NzExODBlMmUyMzgyODZjMjg1N2I1ZTU4ODQwZGEwNzQwNGU2MGE=
   data.tar.gz: !binary |-
-    N2ZlMTBjNGZhMzBhMWNmZDE5OWI3MWZhOTIxNGNmMDFiOGQ2YzAyYzExOWQ3
-    M2JmZTQxYzg4MzM2MTA0ODFmM2Y3NTcwYzY1Y2EyZjQ3MjgzMjQ5NDg4YWIx
-    MzA3ZDhjOTBkNTBkMTQ4Y2E1NTAyN2VmNTU0MTk4NTYxNmY2ODY=
+    ZjVmOTFlMzExYTI4YzlhOWViYTMzZDE1M2FlY2U0Y2JlMWE5OWQ5Nzk4ZmUy
+    ZTI1YTE3NzAyNTM5YWFlNzk3NWQ5MDQ2ZTlhNDdmMGJkZjFhYmQyZDc4OTlm
+    YzQ4OGYzODM5NTNlYjFjZGFlZjA0YmEzOGFkMGUwOTViMzY3NDI=

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.7.0.pre1
+
+[Full Changelog](http://github.com/typhoeus/typhoeus/compare/v0.6.9...v0.7.0.pre1)
+
+Enhancements:
+
+* Improving timeout behavior and documentation. `no_signal` is now set per default!
+  ([Jonas Wagner](https://github.com/jwagner), [\#398](https://github.com/typhoeus/typhoeus/pull/398)
+
 ## 0.6.8
 
 [Full Changelog](http://github.com/typhoeus/typhoeus/compare/v0.6.7...v0.6.8)

data/README.md

@@ -74,7 +74,7 @@ The response object will be set after the request is run.
 response = request.response
 response.code
 response.total_time
-response.headers_hash
+response.headers
 response.body
 ```
 
@@ -165,25 +165,54 @@ request.run
 
 ### Making Parallel Requests
 
-Generally, you should be running requests through hydra. Here is how that looks
+Generally, you should be running requests through hydra. Here is how that looks:
 
 ```ruby
 hydra = Typhoeus::Hydra.hydra
 
-first_request = Typhoeus::Request.new("www.example.com/posts/1.json")
+first_request = Typhoeus::Request.new("http://example.com/posts/1")
 first_request.on_complete do |response|
-  third_request = Typhoeus::Request.new("www.example.com/posts/3.json")
+  third_url = response.body
+  third_request = Typhoeus::Request.new(third_url)
   hydra.queue third_request
 end
-second_request = Typhoeus::Request.new("www.example.com/posts/2.json")
+second_request = Typhoeus::Request.new("http://example.com/posts/2")
 
 hydra.queue first_request
 hydra.queue second_request
-# this is a blocking call that returns once all requests are complete
+hydra.run # this is a blocking call that returns once all requests are complete
+```
+
+The execution of that code goes something like this. The first and second requests are built and queued. When hydra is run the first and second requests run in parallel. When the first request completes, the third request is then built and queued, in this example based on the result of the first request. The moment it is queued Hydra starts executing it.  Meanwhile the second request would continue to run (or it could have completed before the first). Once the third request is done, `hydra.run` returns.
+
+How to get an array of response bodies back after executing a queue:
+
+```ruby
+hydra = Typhoeus::Hydra.new
+requests = 10.times.map { 
+  request = Typhoeus::Request.new("www.example.com", followlocation: true)
+  hydra.queue(request) 
+  request
+}
 hydra.run
+
+responses = requests.map { |request|
+  request.response.body
+}
 ```
+`hydra.run` is a blocking request. You can also use the `on_complete` callback to handle each request as it completes:
 
-The execution of that code goes something like this. The first and second requests are built and queued. When hydra is run the first and second requests run in parallel. When the first request completes, the third request is then built and queued up. The moment it is queued Hydra starts executing it.  Meanwhile the second request would continue to run (or it could have completed before the first). Once the third request is done, `hydra.run` returns.
+```ruby
+hydra = Typhoeus::Hydra.new
+10.times do 
+  request = Typhoeus::Request.new("www.example.com", followlocation: true)
+  request.on_complete do |response|
+    #do_something_with response
+  end
+  hydra.queue(request)
+end
+hydra.run
+```
 
 ### Specifying Max Concurrency
 
@@ -318,17 +347,27 @@ end
 
 ### Timeouts
 
-No exceptions are raised on HTTP timeouts. You can check whether a request timed out with the following methods:
+No exceptions are raised on HTTP timeouts. You can check whether a request timed out with the following method:
 
 ```ruby
-Typhoeus.get("www.example.com").timed_out?
+Typhoeus.get("www.example.com", timeout: 1).timed_out?
 ```
 
+Timed out responses also have their success? method return false.
+
 There are two different timeouts available: [`timeout`](http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTTIMEOUT)
-and [`connecttimeout`](http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTCONNECTTIMEOUT). `timeout` is the
-maximum time in seconds that you allow the libcurl transfer operation to take and `connecttimeout` is the maximum
-time in seconds that you allow the connection to the server to take. These two are always available, while `timeout_ms` ond
-`connecttimeout_ms` accept milliseconds but only an option when curl is build with `c-ares`, it will use `timout` or `connecttimeout` otherwise.
+and [`connecttimeout`](http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTCONNECTTIMEOUT).
+`timeout` is the time limit for the entire request in seconds.
+`connecttimeout` is the time limit for just the connection phase, again in seconds.
+
+There are two additional more fine grained opptions `timeout_ms` and
+`connecttimeout_ms`. These options offer millisecond precision but are not always available (for instance on linux if `nosignal` is not set to true).
+
+When you pass a floating point `timeout` (or `connecttimeout`) Typhoeus will set `timeout_ms` for you if it has not been defined. The actual timeout values passed to curl will always be rounded up.
+
+DNS timeouts of less than one second are not supported unless curl is compiled with an asynchronous resolver.
+
+The default `timeout` is 0 (zero) which means curl never times out during transfer. The default `connecttimeout` is 300 seconds. A `connecttimeout` of 0 will also result in the default `connecttimeout` of 300 seconds.
 
 ### Following Redirections
 
@@ -350,6 +389,14 @@ Typhoeus::Request.get("www.example.com", userpwd: "user:password")
 Typhoeus.get("www.example.com", accept_encoding: "gzip")
 ```
 
+The above has a different behavior than setting the header directly in the header hash, eg:
+```ruby
+Typhoeus.get("www.example.com", headers: {"Accept-Encoding" => "gzip"})
+```
+
+Setting the header hash directly will not include the `--compressed` flag in the libcurl command and therefore libcurl will not decompress the response.  If you want the `--compressed` flag to be added automatically, set `:accept_encoding` Typhoeus option.
+
+
 ### Cookies
 
 ```ruby

data/lib/rack/typhoeus/middleware/params_decoder/helper.rb

@@ -64,7 +64,7 @@ module Rack
           # @return [Arraya/Hash]
           def convert(hash)
             if encoded?(hash)
-              Hash[hash.sort].values
+              hash.sort{ |a, b| a[0].to_i <=> b[0].to_i }.map{ |key, value| value }
             else
               hash
             end

data/lib/typhoeus/easy_factory.rb

@@ -64,19 +64,43 @@ module Typhoeus
     private
 
     def sanitize(options)
-      sanitized = {}
+      # set nosignal to true by default
+      # this improves thread safety and timeout behavior
+      sanitized = {:nosignal => true}
       request.options.each do |k,v|
-        next if [:method, :cache_ttl].include?(k.to_sym)
+        s = k.to_sym
+        next if [:method, :cache_ttl].include?(s)
         if new_option = renamed_options[k.to_sym]
           warn("Deprecated option #{k}. Please use #{new_option} instead.")
           sanitized[new_option] = v
+        # sanitize timeouts
+        elsif [:timeout_ms, :connecttimeout_ms].include?(s)
+          if !v.integer?
+            warn("Value '#{v}' for option '#{k}' must be integer.")
+          end
+          sanitized[k] = v.ceil
         else
           sanitized[k] = v
         end
       end
+
+      sanitize_timeout!(sanitized, :timeout)
+      sanitize_timeout!(sanitized, :connecttimeout)
+
       sanitized
     end
 
+    def sanitize_timeout!(options, timeout)
+      timeout_ms = (timeout.to_s + '_ms').to_sym
+      if options[timeout] && options[timeout].round != options[timeout]
+        if !options[timeout_ms]
+          options[timeout_ms] = (options[timeout]*1000).ceil
+        end
+        options[timeout] = options[timeout].ceil
+      end
+      options
+    end
+
     # Sets on_complete callback on easy in order to be able to
     # track progress.
     #

data/lib/typhoeus/request.rb

@@ -1,4 +1,5 @@
 require 'zlib'
+require 'digest/sha1'
 require 'typhoeus/request/actions'
 require 'typhoeus/request/before'
 require 'typhoeus/request/block_connection'
@@ -162,7 +163,7 @@ module Typhoeus
     #
     # @return [ String ] The cache key.
     def cache_key
-      "#{self.class.name}#{base_url}#{hashable_string_for(options)}"
+      Digest::SHA1.hexdigest "#{self.class.name}#{base_url}#{hashable_string_for(options)}"
     end
 
     # Mimics libcurls POST body generation. This is not accurate, but good

data/lib/typhoeus/version.rb

@@ -1,5 +1,5 @@
 module Typhoeus
 
   # The current Typhoeus version.
-  VERSION = '0.6.9'
+  VERSION = '0.7.0.pre1'
 end

data/spec/rack/typhoeus/middleware/params_decoder/helper_spec.rb

@@ -39,6 +39,30 @@ describe "Rack::Typhoeus::Middleware::ParamsDecoder::Helper" do
           end
         end
 
+        context "when longer and more complex" do
+          let(:params) do
+            {
+              :ids => {
+                "0"  => "407304",
+                "1"  => "407305",
+                "2"  => "407306",
+                "3"  => "407307",
+                "4"  => "407308",
+                "5"  => "407309",
+                "6"  => "407310",
+                "7"  => "407311",
+                "8"  => "407312",
+                "9"  => "407313",
+                "10" => "327012"
+              }
+            }
+          end
+
+          it "decodes ensuring arrays maintain their original order" do
+            expect(decoded[:ids]).to eq(["407304", "407305", "407306", "407307", "407308", "407309", "407310", "407311", "407312", "407313", "327012"])
+          end
+        end
+
         context "when nested" do
           let(:params) do
             { :array => { '0' => 0, '1' => { '0' => 'sub0', '1' => 'sub1' } } }

data/spec/typhoeus/easy_factory_spec.rb

@@ -15,6 +15,47 @@ describe Typhoeus::EasyFactory do
         expect(easy_factory.get).to be_a(Ethon::Easy)
       end
     end
+    
+    context "timeouts" do
+      it "sets nosignal to true by default" do
+        expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:nosignal => true))
+        easy_factory.get
+      end
+
+      context "when timeout is not a whole number and timeout_ms is not set" do
+        let(:options) { {:timeout => 0.1} }
+        it "ceils timeout and sets timeout_ms" do
+          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:timeout_ms => 100, :timeout => 1))
+          easy_factory.get
+        end
+      end
+
+      context "when timeout is not a whole number and timeout_ms is set" do
+        let(:options) { {:timeout => 0.1, :timeout_ms => 123} }
+        it "ceils timeout and does not change timeout_ms" do
+          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:timeout_ms => 123, :timeout => 1))
+          easy_factory.get
+        end
+      end
+
+      context "when connecttimeout is not a whole number and connecttimeout_ms is not set" do
+        let(:options) { {:connecttimeout => 0.1} }
+        it "ceils connecttimeout and sets connecttimeout_ms" do
+          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:connecttimeout_ms => 100, :connecttimeout => 1))
+          easy_factory.get
+        end
+      end
+
+      context "when connecttimeout is not a whole number and connecttimeout_ms is set" do
+        let(:options) { {:connecttimeout => 0.1, :connecttimeout_ms => 123} }
+        it "ceils connecttimeout and does not change connecttimeout_ms" do
+          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:connecttimeout_ms => 123, :connecttimeout => 1))
+          easy_factory.get
+        end
+      end
+
+
+    end
 
     context "when invalid option" do
       let(:options) { {:invalid => 1} }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typhoeus
 version: !ruby/object:Gem::Version
-  version: 0.6.9
+  version: 0.7.0.pre1
 platform: ruby
 authors:
 - David Balatero
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-01 00:00:00.000000000 Z
+date: 2014-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ethon