manticore 0.2.1-java → 0.3.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79bd078a381a202fd2e4e022b384b454fdb80242
-  data.tar.gz: 892736cf30a0c490cb92cf690e5e8aa7eb881368
+  metadata.gz: 0078d294015d5ca40a8e4afadc48973fb9246de1
+  data.tar.gz: bcff310d2a92c1e592cac51f63859a3ee483b63f
 SHA512:
-  metadata.gz: 03a61af6c2dce93aaa68088b9e605cdcb06c8813a182d04ef17152893947b9e9b58b4031561eab68376eb044e08afcd2aa29bd0cc6448f1fa10a4b786b664e71
-  data.tar.gz: 54e578d3b61ac6db04cb60fb13919ddbf157ca0b664e5a066d56eb2ac727ff7798b644ead04e054c74820123a93ec1607c128b1eee9a60dd445d86c8851ae0ac
+  metadata.gz: ef8bfdbaf46d56810e0f137fb4cf96425a46bc22ecf157f9451093bcf9acf721ff4cff86161593ec7c95112a64793856e5345c19454569d0b3ca457c3216d99f
+  data.tar.gz: cd2bcc65d8d377d8622fae139e0f4c5e91816bcd0cea3926c8d1a5503eda2e68c28ef179cae5f153a389cd8c1474bb5ffbb3f789408e197f8d297b385b741e0a

checksums.yaml.gz.sig

@@ -0,0 +1 @@
+h>Ĭ��odd(��`���P��{F�҆<U����$�ѐ�/#�5q�6�>q�>��NJ�YE�'
��P�[���򳽠8EP���>��a�W�"{vh��|�0���W`Or���x?a�L:{�=�������	ѫ�5c���>.��n�[5n%ph����,�Ҳ{b��L�D��l�G����Q�-hn�K�:�X[v^d�ܨjj�X���ޔO�i!����tmK�U�k��z9���힏3Ͽ~�2�x�<uY

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+## v0.3
+### v0.3.0 (pending)
+
+* Major refactor of `Response`/`AsyncResponse` to eliminate redundant code. `AsyncResponse` has been removed and
+  its functionality has been rolled into `Response`.
+* Added `StubbedResponse`, a subclass of `Response`, to be used for stubbing requests/responses for testing.
+* Added `Client#stub`, `Client#unstub` and `Client#respond_with`
+* Responses are now lazy-evaluated by default (similar to how `AsyncResponse` used to behave). The following
+  rules apply:
+  * Synchronous responses which do NOT pass a block are lazy-evaluated the first time one of their results is requested.
+  * Synchronous responses which DO pass a block are evaluated immediately, and are passed to the handler block.
+  * Async responses are always evaluted when `Client#execute!` is called.
+* You can evaluate a `Response` at any time by invoking `#call` on it. Invoking an async response before `Client#execute`
+  is called on it will cause `Client#execute` to throw an exception.
+* Responses (both synchronous and async) may use on_success handlers and the like.
+
+## v0.2
+### v0.2.1
+
+* Added basic auth support
+* Added proxy support
+* Added support for per-request cookies (as opposed to per-session cookies)
+* Added a `Response#cookies` convenience method.
+
+### v0.2.0
+
+* Added documentation and licenses
+* Significant performance overhaul
+* Response handler blocks are now only yielded the Response. `#request` is available on
+  the response object.
+* Patched httpclient.jar to address https://issues.apache.org/jira/browse/HTTPCLIENT-1461

data/README.md

@@ -34,6 +34,7 @@ Or install it yourself as:
   * Transparent gzip and deflate handling
   * Transparent cookie handling
   * Both synchronous and asynchronous execution models
+  * Lazy evaluation
   * Authentication
   * Proxy support
   * SSL
@@ -44,77 +45,199 @@ Or install it yourself as:
 
 If you don't want to worry about setting up and maintaining client pools, Manticore comes with a facade that you can use to start making requests right away:
 
-    Manticore.get "http://www.google.com/"
+```ruby
+document_body = Manticore.get("http://www.google.com/").body
+```
 
 Additionally, you can mix the `Manticore::Facade` into your own class for similar behavior:
 
-    class MyClient
-      include Manticore::Facade
-      include_http_client user_agent: "MyClient/1.0"
-    end
+```ruby
+class MyClient
+  include Manticore::Facade
+  include_http_client user_agent: "MyClient/1.0"
+end
 
-    MyClient.get "http://www.google.com/"
+response_code = MyClient.get("http://www.google.com/").code
+```
 
 Mixing the client into a class will create a new new pool. If you want to share a single pool between clients, specify the `shared_pool` option:
 
-    class MyClient
-      include Manticore::Facade
-      include_http_client shared_pool: true
-    end
+```ruby
+class MyClient
+  include Manticore::Facade
+  include_http_client shared_pool: true
+end
 
-    class MyOtherClient
-      include Manticore::Facade
-      include_http_client shared_pool: true
-    end
+class MyOtherClient
+  include Manticore::Facade
+  include_http_client shared_pool: true
+end
+```
 
 ### More Control
 
 Manticore is built around a connection pool. When you create a `Client`, you will pass various parameters that it will use to set up the pool.
 
-    client = Manticore::Client.new(request_timeout: 5, connect_timeout: 5, socket_timeout: 5, pool_max: 10, pool_max_per_route: 2)
+```ruby
+client = Manticore::Client.new(request_timeout: 5, connect_timeout: 5, socket_timeout: 5, pool_max: 10, pool_max_per_route: 2)
+```
 
 Then, you can make requests from the client. Pooling and route maximum constraints are automatically managed:
 
-    response = client.get("http://www.google.com/")
+```ruby
+response = client.get("http://www.google.com/")
+body = response.body
+```
 
 It is recommend that you instantiate a client once, then re-use it, rather than instantiating a new client per request.
 
 Additionally, if you pass a block to the initializer, the underlying [HttpClientBuilder](http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/impl/client/HttpClientBuilder.html) and [RequestConfig.Builder](http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/client/config/RequestConfig.Builder.html) will be yielded so that you can operate on them directly:
 
-    client = Manticore::Client.new(socket_timeout: 5) do |http_client_builder, request_builder|
-      http_client_builder.disable_redirect_handling
-    end
+```ruby
+client = Manticore::Client.new(socket_timeout: 5) do |http_client_builder, request_builder|
+  http_client_builder.disable_redirect_handling
+end
+```
 
 ### Parallel execution
 
-Manticore can perform multiple concurrent execution of requests.
+Manticore can perform concurrent execution of multiple requests.
 
-    client = Manticore::Client.new
+```ruby
+client = Manticore::Client.new
 
-    # These aren't actually executed until #execute! is called.
-    # You can define response handlers in a block when you queue the request:
-    client.async_get("http://www.google.com") {|req|
-      req.on_success do |response|
-        puts response.body
-      end
+# These aren't actually executed until #execute! is called.
+# You can define response handlers in a block when you queue the request:
+client.async.get("http://www.google.com") {|req|
+  req.on_success do |response|
+    puts response.body
+  end
 
-      req.on_failure do |exception|
-        puts "Boom! #{exception.message}"
-      end
-    }
+  req.on_failure do |exception|
+    puts "Boom! #{exception.message}"
+  end
+}
 
-    # ...or by invoking the method on the queued response returned:
-    response = client.async_get("http://www.yahoo.com")
-    response.on_success do |response|
-      puts "The length of the Yahoo! homepage is #{response.body.length}"
-    end
+# ...or by invoking the method on the queued response returned:
+response = client.async.get("http://www.yahoo.com")
+response.on_success do |response|
+  puts "The length of the Yahoo! homepage is #{response.body.length}"
+end
 
-    # ...or even by chaining them onto the call
-    client.async_get("http://bing.com").
-      on_success {|r| puts r.code }.
-      on_failure {|e| puts "on noes!"}
+# ...or even by chaining them onto the call
+client.async.get("http://bing.com").
+  on_success {|r| puts r.code }.
+  on_failure {|e| puts "on noes!"}
 
-    client.execute!
+client.execute!
+```
+
+### Lazy Evaluation
+
+Manticore attempts to avoid doing any actual work until right before you need results. As a result,
+responses are lazy-evaluated as late as possible. The following rules apply:
+
+1. Synchronous responses are evaluted when you call an accessor on them, like `#body` or `#headers`.
+2. Synchronous responses which pass a handler block are evaluated immediately.
+3. Asynchronous responses are always evaluated when you call `Client#execute!`
+4. Background responses are always immediately evaluated, but return a `Future`.
+
+As a result, with the exception of background requests, this allows you to attach handlers to synchronous
+and asynchronous responses in the same fashion:
+
+```ruby
+# Response doesn't evaluate when you call get, since you don't need any results from it yet
+response = client.get("http://google.com").on_success {|r| "Success handler!" }
+# As soon as you request #body, the response will evaluate to a result.
+body = response.body
+
+response = client.async.get("http://google.com").on_success {|r| "Success handler!" }
+client.execute!
+body = response.body
+```
+
+If you want to make a response that is not lazy-evaluated, you can either pass a handler block to it, or you can
+call `#call` on the resulting response:
+
+```ruby
+# This will evaluate immediately
+client.get("http://google.com") {r| r.body }
+
+# As will this, via explicit invocation of #call
+client.get("http://google.com").call
+```
+
+### Stubbing
+
+Manticore provides a stubbing interface somewhat similar to Typhoeus'
+
+```ruby
+client.stub("http://google.com", body: "response body", code: 200)
+client.get("http://google.com") do |response|
+  response.body.should == "response body"
+end
+client.clear_stubs!
+```
+
+This works for async requests as well:
+
+```ruby
+client.stub("http://google.com", body: "response body", code: 200)
+
+# The request to google.com returns a stub as expected
+client.async.get("http://google.com").on_success do |response|
+  response.should be_a Manticore::ResponseStub
+end
+
+# Since yahoo.com isn't stubbed, a full request will be performed
+client.async.get("http://yahoo.com").on_success do |response|
+  response.should be_a Manticore::Response
+end
+client.clear_stubs!
+```
+
+If you don't want to worry about stub teardown, you can just use `#respond_with`, which will stub the next
+response the client makes with a ResponseStub rather than permitting it to execute a remote request.
+
+```ruby
+client.respond_with(body: "body").get("http://google.com") do |response|
+  response.body.should == "body"
+end
+```
+
+You can also chain proxies to, say, stub an async request:
+
+```ruby
+response = client.async.respond_with(body: "response body").get("http://google.com")
+client.execute!
+
+response.body.should == "response body"
+```
+
+Additionally, you can stub and unstub individual URLs as desired:
+```ruby
+client.stub("http://google.com", body: "response body", code: 200)
+client.stub("http://yahoo.com",  body: "response body", code: 200)
+
+# The request to google.com returns a stub as expected
+client.get("http://google.com") do |response|
+  response.should be_a Manticore::ResponseStub
+end
+
+# After this point, yahoo will remain stubbed, while google will not.
+client.unstub("http://google.com")
+```
+
+### Background requests
+
+You might want to fire-and-forget requests without blocking your calling thread. You can do this with `Client#background`:
+
+```ruby
+future = client.background.get("http://google.com")
+# The request is now running, but the calling thread isn't blocked
+# Do whatever stuff you need to right now. At some point, if you want the result of the request, you can call `Future#get`:
+response = future.get
+```
 
 ## Contributing
 

data/gem-public_cert.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDaDCCAlCgAwIBAgIBATANBgkqhkiG9w0BAQUFADA9MQ8wDQYDVQQDDAZjaGVh
+bGQxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2NvbTAe
+Fw0xNDAzMDEyMTE4MzJaFw0xNTAzMDEyMTE4MzJaMD0xDzANBgNVBAMMBmNoZWFs
+ZDEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29tMIIB
+IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwcnX2yl+rbjUztC4V+iUJgWv
+NPxqU4bQBaL+w00wVABWr04Hjg+cEkqiJ6A0kXxZIz5uXKhhvsaO50NvHfplVcUf
+BxQabIfCS79xdvexXN0or3F5saatGaGa4cj/0uUHjX7w+K5MpEVfbjJp0uAKp62B
+wUU2ilmn7EvZhEUPOMQi01t8z8OsOGc8kF2UtU1kGCxLV7eThWqu8CdXrux5E140
+7SnFnPlnXNeHqwZdOMZzQ9PiTQAPCKO3AY0aBFQeG3wlFPqkcEjOrtV1h7werUwz
+aNb4t5sAuu0f/9B646BOjiMgj1WeUlhgiAsaF5kVvLFNCxwS/xpcN3X01M2KdQID
+AQABo3MwcTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUtFVpwfEG
+78mBd2ulzsS+SlffdOcwGwYDVR0RBBQwEoEQY2hlYWxkQGdtYWlsLmNvbTAbBgNV
+HRIEFDASgRBjaGVhbGRAZ21haWwuY29tMA0GCSqGSIb3DQEBBQUAA4IBAQANcBIJ
+vIk27iNu4Ic6awNRy4Rd2YchzW4DaMhfpTXxtYWgAE502OdqUTFtmihd2PmnVRIP
+xdP5K2SpbCLuLKFCZ825qp8R02JSNMdgi2d4Btl0vHSO8O3lQ1ZAOM1BZPn2+Kbn
+KsiSURg3SnDXItcoedMsS+CQdNyBSdqvpkQ5gn22dN4BSwJg5ApwEYJ9tTuTpRXt
+1KCQFe5hamoenfoHO6uUXPEs24PUHnXl8QibWCLbt1FIBpTrJYNGiMHHnB7ip+zv
+E7PWS50D9moUJ6xWcemf0qKYC87qBFh0ng73awjG9uf+13lMslqJRMtek8C92cvh
++R9zgQlbeNjy9O1i
+-----END CERTIFICATE-----

data/lib/manticore/client/proxies.rb

@@ -0,0 +1,57 @@
+module Manticore
+  class Client
+    module ProxiesInterface
+      def respond_with(stubs)
+        StubProxy.new(self, stubs)
+      end
+
+      # Causes the next request to be made asynchronously
+      def async
+        AsyncProxy.new(self)
+      end
+
+      # Causes the next request to be made immediately in the background
+      def background
+        BackgroundProxy.new(self)
+      end
+    end
+
+    class BaseProxy
+      include ProxiesInterface
+      def initialize(client)
+        @client = client
+      end
+    end
+
+    class AsyncProxy < BaseProxy
+      %w(get put head post options patch).each do |func|
+        define_method func do |url, options = {}, &block|
+          @client.send(func, url, options.merge(async: true), &block)
+        end
+      end
+    end
+
+    class StubProxy < BaseProxy
+      def initialize(client, stubs)
+        super(client)
+        @stubs = stubs
+      end
+
+      %w(get put head post options patch).each do |func|
+        define_method func do |url, options = {}, &block|
+          @client.stub(url, @stubs)
+          @client.send(func, url, options, &block).complete { @client.unstub url }
+        end
+      end
+    end
+
+    class BackgroundProxy < BaseProxy
+      %w(get put head post options patch).each do |func|
+        define_method func do |url, options = {}, &block|
+          request = @client.send(func, url, options.merge(async: true), &block)
+          @client.executor.java_method(:submit, [java.util.concurrent.Callable.java_class]).call request
+        end
+      end
+    end
+  end
+end

data/lib/manticore/client.rb

@@ -37,7 +37,12 @@ module Manticore
   #
   # @!macro [new] http_method_shared_sync
   #   @example Simple usage
-  #     client.$0("http://example.com/some/resource", params: {foo: "bar"}, headers: {"X-Custom-Header" => "whee"})
+  #     body = client.$0("http://example.com/some/resource", params: {foo: "bar"}, headers: {"X-Custom-Header" => "whee"}).body
+  #   @example Passing a block as the success handler:
+  #     body = client.$0("http://example.com/some/resource", params: {foo: "bar"}, headers: {"X-Custom-Header" => "whee"}) {|response| response.body }
+  #   @example Explicit success handler:
+  #     body = client.$0("http://example.com/some/resource", params: {foo: "bar"}, headers: {"X-Custom-Header" => "whee"}).
+  #       on_success {|response| response.body }
   #   @macro http_method_shared
   #   @macro http_request_exceptions
   #
@@ -66,13 +71,11 @@ module Manticore
     include_package "java.util.concurrent"
     include_package "org.apache.http.client.protocol"
     java_import "org.apache.http.HttpHost"
+    include ProxiesInterface
 
     # The default maximum pool size for requests
     DEFAULT_MAX_POOL_SIZE   = 50
 
-    # The default maximum number of threads per route that will be permitted
-    DEFAULT_MAX_PER_ROUTE   = 10
-
     DEFAULT_REQUEST_TIMEOUT = 60
     DEFAULT_SOCKET_TIMEOUT  = 10
     DEFAULT_CONNECT_TIMEOUT = 10
@@ -99,7 +102,7 @@ module Manticore
     # @param options [Hash] Client pool options
     # @option options [String]  user_agent                 The user agent used in requests.
     # @option options [Integer] pool_max           (50)    The maximum number of active connections in the pool
-    # @option options [integer] pool_max_per_route (2)     Sets the maximum number of active connections for a given target endpoint
+    # @option options [integer] pool_max_per_route (pool_max) Sets the maximum number of active connections for a given target endpoint
     # @option options [boolean] cookies            (true)  enable or disable automatic cookie management between requests
     # @option options [boolean] compression        (true)  enable or disable transparent gzip/deflate support
     # @option options [integer] request_timeout    (60)    Sets the timeout for requests. Raises {Manticore::Timeout} on failure.
@@ -112,6 +115,9 @@ module Manticore
     # @option options [String]  proxy              Proxy host in form: http://proxy.org:1234
     # @option options [Hash]    proxy              Proxy host in form: {host: 'proxy.org'[, port: 80[, scheme: 'http']]}
     # @option options [URI]     proxy              Proxy host as a URI object
+    # @option options [Boolean/Integer] keepalive  (true) Whether to allow connections to be reused. Defaults to true. If an integer,
+    #                                                     then connections will be kept alive for this long when Connection: keep-alive
+    #                                                     is sent, but no Keep-Alive header is sent.
     def initialize(options = {})
       builder  = client_builder
       builder.set_user_agent options.fetch(:user_agent, "Manticore #{VERSION}")
@@ -121,10 +127,20 @@ module Manticore
       builder.set_proxy get_proxy_host(options[:proxy]) if options.key?(:proxy)
 
       # This should make it easier to reuse connections
-      builder.disable_connection_state
-      builder.set_connection_reuse_strategy DefaultConnectionReuseStrategy.new
+      # TODO: Determine what this actually does!
+      # builder.disable_connection_state
+
+      keepalive = options.fetch(:keepalive, true)
+      if keepalive == false
+        builder.set_connection_reuse_strategy {|response, context| false }
+      else
+        builder.set_connection_reuse_strategy DefaultConnectionReuseStrategy.new
+      end
+
+      socket_config_builder = SocketConfig.custom
+      socket_config_builder.setSoTimeout( options.fetch(:socket_timeout, DEFAULT_SOCKET_TIMEOUT) * 1000 )
+      builder.set_default_socket_config socket_config_builder.build
 
-      # socket_config = SocketConfig.custom.set_tcp_no_delay(true).build
       builder.set_connection_manager pool(options)
 
       request_config = RequestConfig.custom
@@ -134,7 +150,6 @@ module Manticore
       request_config.set_max_redirects                  options.fetch(:max_redirects, DEFAULT_MAX_REDIRECTS)
       request_config.set_expect_continue_enabled        options.fetch(:expect_continue, DEFAULT_EXPECT_CONTINUE)
       request_config.set_stale_connection_check_enabled options.fetch(:stale_check, DEFAULT_STALE_CHECK)
-      # request_config.set_authentication_enabled         options.fetch(:use_auth, false)
       request_config.set_circular_redirects_allowed false
 
       yield builder, request_config if block_given?
@@ -143,6 +158,18 @@ module Manticore
       @client = builder.build
       @options = options
       @async_requests = []
+      @stubs = {}
+    end
+
+    # Return a hash of statistics about this client's HTTP connection pool
+    def pool_stats
+      stats = @pool.get_total_stats
+      {
+        max: stats.get_max,
+        leased: stats.get_leased,
+        pending: stats.get_pending,
+        available: stats.get_available
+      }
     end
 
     ### Sync methods
@@ -177,58 +204,39 @@ module Manticore
       request HttpDelete, url, options, &block
     end
 
+    # Perform a HTTP OPTIONS request
     # @macro http_method_shared_sync
     def options(url, options = {}, &block)
       request HttpOptions, url, options, &block
     end
 
+    # Perform a HTTP PATCH request
     # @macro http_method_shared_sync_with_body
     def patch(url, options = {}, &block)
       request HttpPatch, url, options, &block
     end
 
-    ### Async methods
-
-    # Queue an asynchronous HTTP GET request
-    # @macro http_method_shared_async
-    def async_get(url, options = {}, &block)
-      get url, options.merge(async: true), &block
-    end
-
-    # Queue an asynchronous HTTP HEAD request
-    # @macro http_method_shared_async
-    def async_head(url, options = {}, &block)
-      head url, options.merge(async: true), &block
-    end
-
-    # Queue an asynchronous HTTP PUT request
-    # @macro http_method_shared_async_with_body
-    def async_put(url, options = {}, &block)
-      put url, options.merge(async: true), &block
-    end
-
-    # Queue an asynchronous HTTP POST request
-    # @macro http_method_shared_async_with_body
-    def async_post(url, options = {}, &block)
-      post url, options.merge(async: true), &block
+    %w(get put head post options patch).each do |func|
+      define_method "#{func}!" do |url, options, &block|
+        send(func, url, options, &block).call
+      end
     end
 
-    # Queue an asynchronous HTTP DELETE request
-    # @macro http_method_shared_async
-    def async_delete(url, options = {}, &block)
-      delete url, options.merge(async: true), &block
+    # Cause this client to return a stubbed response for this URL
+    # @param  url [String] URL to stub for
+    # @param  stubs [Hash] Hash of options to return for the stubbed response
+    def stub(url, stubs)
+      @stubs[url] = stubs
     end
 
-    # Queue an asynchronous HTTP OPTIONS request
-    # @macro http_method_shared_async
-    def async_options(url, options = {}, &block)
-      options url, options.merge(async: true), &block
+    # Cause this client to unstubbed previously-stubbed URL
+    def unstub(url)
+      @stubs.delete(url)
     end
 
-    # Queue an asynchronous HTTP PATCH request
-    # @macro http_method_shared_async_with_body
-    def async_patch(url, options = {}, &block)
-      patch url, options.merge(async: true), &block
+    # Wipe all currently-set stubs.
+    def clear_stubs!
+      @stubs.clear
     end
 
     # Remove all pending asynchronous requests.
@@ -243,9 +251,16 @@ module Manticore
     #
     # @return [Array] An array of the responses from the requests executed.
     def execute!
-      result = @executor.invoke_all(@async_requests).map(&:get)
+      method = executor.java_method(:submit, [java.util.concurrent.Callable.java_class])
+      result = @async_requests.map {|r| method.call r }
       @async_requests.clear
-      result
+      result.map(&:get)
+    end
+
+    # Get at the underlying ExecutorService used to invoke asynchronous calls.
+    def executor
+      create_executor_if_needed
+      @executor
     end
 
     protected
@@ -262,7 +277,7 @@ module Manticore
       @pool ||= begin
         @max_pool_size = options.fetch(:pool_max, DEFAULT_MAX_POOL_SIZE)
         cm = pool_builder
-        cm.set_default_max_per_route options.fetch(:pool_max_per_route, DEFAULT_MAX_PER_ROUTE)
+        cm.set_default_max_per_route options.fetch(:pool_max_per_route, @max_pool_size)
         cm.set_max_total @max_pool_size
         Thread.new {
           loop {
@@ -283,35 +298,35 @@ module Manticore
     def request(klass, url, options, &block)
       req, context = request_from_options(klass, url, options)
       if options.delete(:async)
-        async_request req, context, &block
+        async_request req, context
       else
         sync_request req, context, &block
       end
     end
 
-    def async_request(request, context, &block)
+    def async_request(request, context)
       create_executor_if_needed
-      response = AsyncResponse.new(@client, request, context, block)
+      response = response_object_for(@client, request, context)
       @async_requests << response
       response
     end
 
     def sync_request(request, context, &block)
-      response = Response.new(request, context, block)
-      begin
-        @client.execute request, response, response.context
+      response = response_object_for(@client, request, context, &block)
+      if block_given?
+        response.call
+      else
         response
-      rescue Java::JavaNet::SocketTimeoutException, Java::OrgApacheHttpConn::ConnectTimeoutException, Java::OrgApacheHttp::NoHttpResponseException => e
-        raise Manticore::Timeout.new(e.get_cause)
-      rescue Java::JavaNet::SocketException => e
-        raise Manticore::SocketException.new(e.get_cause)
-      rescue Java::OrgApacheHttpClient::ClientProtocolException, Java::JavaxNetSsl::SSLHandshakeException,
-             Java::OrgApacheHttpConn::HttpHostConnectException, Java::JavaxNetSsl::SSLException => e
-        raise Manticore::ClientProtocolException.new(e.get_cause)
-      rescue Java::JavaNet::UnknownHostException => e
-        raise Manticore::ResolutionFailure.new(e.get_cause)
       end
+    end
 
+    def response_object_for(client, request, context, &block)
+      request_uri = request.getURI.to_s
+      if @stubs.key?(request_uri)
+        StubbedResponse.new(client, request, context, &block).stub( @stubs[request_uri] )
+      else
+        Response.new(client, request, context, &block)
+      end
     end
 
     def uri_from_url_and_options(url, options)