px-service-client 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e1b9f1c89d04e85c5a9651110610cd09db6ef51
-  data.tar.gz: c7c29ca34280c62c4bdfb5f509975d2f805b9a1b
+  metadata.gz: db46c3146668dad3c40c3a5cabc1feaf4743b745
+  data.tar.gz: 94824bed638685d41404aee9739453fdc2f79280
 SHA512:
-  metadata.gz: bb8754feff57a33821f4f7fb1fe0e3f0e918f127fd339874a7e3e74ed4b1213827764a4b4cc4bc10dad400db052f86094a2898e2e97733de526cb92ab3229dc0
-  data.tar.gz: 6306f318dc756f99d0bcd5a553e2ec77a58fc8bb1afa150aecd246ca355246c6332b3d46673486a2f7759fafc903149b3e85861b996335f281067f6e63367d78
+  metadata.gz: 232d9cee11917707c1463cc1d53a9b1336225ef4cb22d5611a3dce074eb6b2feb9ca7e3b5420b69018f0d4acfa847407b37426519482ffd501df2c66875a1a59
+  data.tar.gz: 1d1b736be0ebc4a91957c09832a34ae892e16690d4f4df9dca211496bc6deb5c3d2f8f46e534999373b0ea51821453ce08cac9dd64a9c0e8bec64b8c2a85f340

data/README.md

@@ -38,7 +38,7 @@ This gem includes several common features used in 500px service client libraries
 The features are:
 
 #### Px::Service::Client::Base
-This class provides a basic `make_request(method, url, ...)` method that produces an asynchronous request. The method immediately returns a `RetriableResponseFuture`. It works together with `Multiplexer`(discussed below) and uses [Typhoeus](https://github.com/typhoeus/typhoeus)  as the underlying HTTP client to support asynchronicity. 
+This class provides a basic `make_request(method, url, ...)` method that produces an asynchronous request. The method immediately returns a `Future`. It works together with `Multiplexer`(discussed below) and uses [Typhoeus](https://github.com/typhoeus/typhoeus)  as the underlying HTTP client to support asynchronicity. 
 
 **Customized clients usually inherit this class and include other features/mixins, if needed.**  
 
@@ -55,7 +55,7 @@ multi = Px::Service::Client::Multiplexer.new
 multi.context do
 	method = :get
 	url = 'http://www.example.com'
-	req = make_request(method, url) # returns a RetriableResponseFuture
+	req = make_request(method, url) # returns a Future
 	multi.do(req) # queues the request/future into hydra
 end
 
@@ -64,9 +64,9 @@ multi.run # a blocking call, like hydra.run
 ```
 `multi.context` encapsulates the block into a [`Fiber`](http://ruby-doc.org/core-2.2.0/Fiber.html) object and immediately runs (or `resume`, in Fiber's term) that fiber until the block explicitly gives up control. The method returns `multi` itself. 
 
-`multi.do(request_or_future,retries)` queues the request into `hydra`. It always returns a `RetriableResponseFuture`. A  [`Typhoeus::Request`](https://github.com/typhoeus/typhoeus) will be converted into a `RetriableResponseFuture ` in this call. 
+`multi.do(request_or_future,retries)` queues the request into `hydra`. It always returns a `Future`. A  [`Typhoeus::Request`](https://github.com/typhoeus/typhoeus) will be converted into a `Future ` in this call. 
 
-Finally, `multi.run` starts `hydra` to execute the requests in parallel. The request is made as soon as the multiplexer is started. You get the results of the request by evaluating the value of the `RetriableResponseFuture`.
+Finally, `multi.run` starts `hydra` to execute the requests in parallel. The request is made as soon as the multiplexer is started. You get the results of the request by evaluating the value of the `Future`.
 
 #### Px::Service::Client::Caching
 
@@ -89,12 +89,29 @@ end
 # An example of a cached request
 result = cache_request(url, :last_resort, refresh_probability: 1) do
 	req = make_request(method, url)
+	response = @multi.do(req)
+	
+	# cache_request() expects a future that returns the result to be cached
+	Px::Service::Client::Future.new do  
+		JSON.parse(response.body)
+	end
 end
 ```
 
-`cache_request` expects a block that does the `make_request` and returns a `RetriableResponseFuture`. The block takes no argument. If neither the cache nor the response has the data, the exception `ServiceError` will be re-raised. 
+`cache_request` expects a block that returns a `Future` object. The return value (usually the response body) of that future will be cached.  `cache_request` always returns a future. By evaluating the future, i.e., via the `Future.value!` call, you get the result (whether cached or not). 
+
+
+**Note**: DO NOT cache the `Typhoeus::Response` directly (See the below code snippet), because the response object cannot be serializable to be stored in memcached. That's the reason why we see warning message: `You are trying to cache a Ruby object which cannot be serialized to memcached.`
+
+```
+# An incorrect example of using cache_request()
+cache_request(url, :last_resort) do
+	req = make_request(method, url)
+	response = @multi.do(req)   # DO NOT do this 
+end
 
-Responses are cached in memcached (using the provided cache client) in either a *last-resort* or *first-resort* manner.
+``` 
+Responses are cached in either a *last-resort* or *first-resort* manner.
 
 *last-resort* means that the cached value is only used when the service client request fails (with a
 `ServiceError`). If the service client request succeeds, there is a chance that the cache value may get refreshed. The `refresh_probability` is provided to let the cached value
@@ -125,7 +142,7 @@ end
 req = make_request(method, url) # overrides Px::Service::Client::Base
 ```
 
-Adds a circuit breaker to the client.  `make_request` always returns `RetriableResponseFuture`
+Adds a circuit breaker to the client.  `make_request` always returns `Future`
 
 The circuit will open on any exception from the wrapped method, or if the request runs for longer than the `invocation_timeout`.
 

data/lib/px/service/client/caching.rb

@@ -72,8 +72,7 @@ module Px::Service::Client
         begin
           raise ArgumentError.new('Block did not return a Future.') unless retry_response.is_a?(Future)
           resp = retry_response.value!
-
-          entry = CacheEntry.new(config.cache_client, url, policy_group, resp.options)
+          entry = CacheEntry.new(config.cache_client, url, policy_group, resp)
 
           # Only store a new result if we roll a 0
           r = rand(refresh_probability)
@@ -88,7 +87,7 @@ module Px::Service::Client
           end
 
           entry.touch(expires_in, refresh_window: 1.minute)
-          Typhoeus::Response.new(HashWithIndifferentAccess.new(entry.data))
+          entry.data
         end
       end
     end
@@ -109,7 +108,7 @@ module Px::Service::Client
           # don't also try to update the cache.
           entry.touch(expires_in)
         else
-          return Future.new { Typhoeus::Response.new(HashWithIndifferentAccess.new(entry.data)) }
+          return Future.new { entry.data }
         end
       end
 
@@ -119,8 +118,7 @@ module Px::Service::Client
         begin
           raise ArgumentError.new('Block did not return a Future.') unless retry_response.is_a?(Future)
           resp = retry_response.value!
-          
-          entry = CacheEntry.new(config.cache_client, url, policy_group, resp.options)
+          entry = CacheEntry.new(config.cache_client, url, policy_group, resp)
           entry.store(expires_in)
           resp
         rescue Px::Service::ServiceError => ex
@@ -135,7 +133,7 @@ module Px::Service::Client
           # Set the entry to be expired again (but reset the refresh window).  This allows the next call to try again
           # (assuming the circuit breaker is reset) but keeps the value in the cache in the meantime
           entry.touch(0.seconds)
-          Typhoeus::Response.new(HashWithIndifferentAccess.new(entry.data))
+          entry.data
         end
       end
 

data/lib/px/service/client/version.rb

@@ -1,7 +1,7 @@
 module Px
   module Service
     module Client
-      VERSION = "1.2.2"
+      VERSION = "1.2.3"
     end
   end
 end

data/spec/px/service/client/base_spec.rb

@@ -67,8 +67,8 @@ describe Px::Service::Client::Base do
         Typhoeus.stub(url).and_return(response)
       end
 
-      shared_examples_for 'a request that returns a cached response' do
-        let(:cache_entry) { Px::Service::Client::Caching::CacheEntry.new(dalli, url, 'general', future, Time.now + 1.year) }
+      shared_examples_for 'a request that returns a cached response body' do
+        let(:cache_entry) { Px::Service::Client::Caching::CacheEntry.new(dalli, url, 'general', response.body, Time.now + 1.year) }
 
         before :each do
           Typhoeus::Expectation.clear
@@ -80,8 +80,10 @@ describe Px::Service::Client::Base do
             multi.context do
               resp = multi.do(req)
             end.run
-            
-            resp
+
+            Px::Service::Client::Future.new do
+              resp.options[:body]
+            end
           end
         end
 
@@ -94,12 +96,14 @@ describe Px::Service::Client::Base do
             multi.context do
               resp = multi.do(req)
             end.run
-            
-            resp
+
+            Px::Service::Client::Future.new do
+              resp.options[:body]
+            end
           end
         end
 
-        it 'returns the cached response' do
+        it 'returns the cached response body' do
           Typhoeus::Expectation.clear
           Typhoeus.stub(url).and_return(response)
           req = subject.send(:make_request, 'get', url)
@@ -108,10 +112,12 @@ describe Px::Service::Client::Base do
 
             multi.context do
               resp = multi.do(req)
-              expect(resp).to eq(cache_entry.data)
-            end.run
+              expect(resp.options[:body]).to eq(cache_entry.data)
+            end
 
-            resp
+            Px::Service::Client::Future.new do
+              resp.options[:body]
+            end
           end
         end
       end
@@ -120,7 +126,7 @@ describe Px::Service::Client::Base do
         let(:strategy) { :first_resort }
         let(:response) { successful_response }
 
-        it_behaves_like 'a request that returns a cached response'
+        it_behaves_like 'a request that returns a cached response body'
 
         context 'when the request fails' do
           let(:response) do
@@ -141,8 +147,10 @@ describe Px::Service::Client::Base do
                   resp = multi.do(req)
                   called = true
                 end.run
-                
-                resp
+
+                Px::Service::Client::Future.new do
+                  resp.options[:body]
+                end
               end
 
               expect(called).to be_truthy
@@ -156,15 +164,17 @@ describe Px::Service::Client::Base do
                   multi.context do
                     resp = multi.do(req)
                   end.run
-                  
-                  resp
+
+                  Px::Service::Client::Future.new do
+                    resp.options[:body]
+                  end
                 end.value!
               }.to raise_error(Px::Service::ServiceError, 'Failed')
             end
           end
 
           context 'when a response has been cached' do
-            it_behaves_like 'a request that returns a cached response'
+            it_behaves_like 'a request that returns a cached response body'
           end
         end
       end
@@ -183,8 +193,10 @@ describe Px::Service::Client::Base do
               resp = multi.do(req)
               called = true
             end.run
-            
-            resp
+
+            Px::Service::Client::Future.new do
+              resp.options[:body]
+            end
           end
 
           expect(called).to be_truthy
@@ -203,14 +215,16 @@ describe Px::Service::Client::Base do
               called = false
               req = subject.send(:make_request, 'get', url)
 
-              subject.cache_request(req.request.url, strategy: strategy) do
+              subject.cache_request(req.request.url, strategy: strategy, refresh_probability: 0) do
                 resp = nil
                 multi.context do
                   resp = multi.do(req)
                   called = true
                 end.run
-                
-                resp
+
+                Px::Service::Client::Future.new do
+                  resp.options[:body]
+                end
               end
 
               expect(called).to be_truthy
@@ -225,14 +239,16 @@ describe Px::Service::Client::Base do
                   multi.context do
                     resp = multi.do(req)
                   end.run
-                  
-                  resp
+
+                  Px::Service::Client::Future.new do
+                    resp.options[:body]
+                  end
                 end.value!
               }.to raise_error(Px::Service::ServiceError, 'Failed')
             end
           end
 
-          context 'when a response has been cached' do
+          context 'when a response body has been cached' do
             before :each do
               Typhoeus::Expectation.clear
               Typhoeus.stub(url).and_return(successful_response)
@@ -245,7 +261,9 @@ describe Px::Service::Client::Base do
                   resp = multi.do(req)
                 end.run
 
-                resp
+                Px::Service::Client::Future.new do
+                  resp.options[:body]
+                end
               end
             end
 
@@ -259,13 +277,15 @@ describe Px::Service::Client::Base do
                   called = true
                 end.run
 
-                resp
+                Px::Service::Client::Future.new do
+                  resp.options[:body]
+                end
               end
 
               expect(called).to be_truthy
             end
 
-            it 'returns the cached response' do
+            it 'returns the cached response body' do
               Typhoeus::Expectation.clear
               Typhoeus.stub(url).and_return(response)
               req = subject.send(:make_request, 'get', url)
@@ -275,9 +295,11 @@ describe Px::Service::Client::Base do
                 multi.context do
                   resp = multi.do(req)
                 end.run
-                
-                resp
-              end.value!.response_code).to be(200)
+
+                Px::Service::Client::Future.new do
+                  resp.options[:body]
+                end
+              end.value!['status']).to be(200)
             end
           end
 

data/spec/px/service/client/caching/caching_spec.rb

@@ -39,7 +39,7 @@ describe Px::Service::Client::Caching do
     it "should call the block" do
       called = false
       subject.cache_request(url, strategy: strategy) do
-        called = true
+        Px::Service::Client::Future.new { called = true }
       end
 
       expect(called).to be_truthy
@@ -131,7 +131,7 @@ describe Px::Service::Client::Caching do
         it "returns the cached response on failure" do
           expect(subject.cache_request(url, strategy: strategy) do
             Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
-          end.value!.options).to eq(response.options.stringify_keys)
+          end.value!).to eq(response.options)
         end
 
         it "does not returns the cached response on request error" do
@@ -195,8 +195,10 @@ describe Px::Service::Client::Caching do
 
         it "returns the response" do
           expect(subject.cache_request(url, strategy: strategy) do
-            nil
-          end.value!.options).to eq(response.options.stringify_keys)
+            Future.new do
+              nil
+            end
+          end.value!).to eq(response.options)
         end
       end
     end
@@ -217,7 +219,10 @@ describe Px::Service::Client::Caching do
       it "invokes the block" do
         called = false
         subject.cache_request(url, strategy: strategy) do |u|
-          called = true
+          Px::Service::Client::Future.new do
+            called = true
+            { stub: "stub str" }.to_hash
+          end
         end
 
         expect(called).to be_truthy
@@ -252,7 +257,7 @@ describe Px::Service::Client::Caching do
             end.run
 
             resp
-          end.value!.options).to eq(response.options.stringify_keys)
+          end.value!).to eq(response.options)
 
           expect(called).to be_falsey
 
@@ -272,13 +277,13 @@ describe Px::Service::Client::Caching do
 
         expect(subject.cache_request(url, strategy: strategy) do
           nil
-        end.value.options).to eq(response.options.stringify_keys)
+        end.value).to eq(response.options)
       end
 
       it "returns the cached response on failure" do
         expect(subject.cache_request(url, strategy: strategy) do
           Px::Service::Client::Future.new { raise Px::Service::ServiceError.new("Error", 500) }
-        end.value!.options).to eq(response.options.stringify_keys)
+        end.value!).to eq(response.options)
       end
 
       it "does not returns the cached response on request error" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: px-service-client
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Chris Micacchi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-19 00:00:00.000000000 Z
+date: 2016-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: will_paginate