manticore 0.4.4-java → 0.5.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e35496eb223648d01aea2dbe4132d88102b599f6
-  data.tar.gz: d87ffe86b45313d8836354c9df4419e3c91c9fd9
+  metadata.gz: 9cf2ddebb1afdaa3ee6044c1796c7ec917ba6485
+  data.tar.gz: 452f05d5e780e13b05f2fd7c004c4cc1c858c67f
 SHA512:
-  metadata.gz: e03381476da9b771bf8961c0767312639147d4bc15435879144f4d37960dcac693bc07c43ab9c963fefe846df76163569483040230d852e1038dcff58157fd7a
-  data.tar.gz: 011f97038fd79f71cb3b734639fa468f3395073efe5697d838543ecbe38f26da94ee005726379fedd54cfac9789d9271169a168b0930b1096568d8d98e5a4901
+  metadata.gz: 53c89c946b6d9ec034dc14282b6bd415cac0dba8c82ffee2f0508d3db17f123c874bce492f79efbc6813111767459f942fc902cf2b6a8a1fd3480f670262d8c6
+  data.tar.gz: 0ecd5d823d6e778e57ebfcf5ee63209f5cf5e67620348a18616ea80ca5751054d577c283ad99392b580933849e2bac9cae1dfa3d277e87be24b6e1da12625b50

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
+sudo: false
 rvm:
   - jruby-1.7
   - jruby-9.0.0.0

data/CHANGELOG.md

@@ -1,13 +1,23 @@
 ## v0.5
 
-### v0.5.0 (pending, hc-4.5 branch)
+### v0.5.1 (pending)
+
+### v0.5.0
 
 * Upgrade to HTTPClient and HTTPCore 4.5
+* BREAKING CHANGE: Background request usage has changed. See [this commit](https://github.com/cheald/manticore/commit/174e2004d1865c201daf77494d50ab66527c12aa) for details.
+* Client#async is now soft-deprecated in favor of Client#parallel or Client#batch, as the latter two more accurately reflect the intended usage. Client#background is for
+  "don't block the calling thread"-style asynchronous calls.
+* Manticore now uses jar-dependencies to install the HTTPComponents et al jars during gem installation, rather than shipping them in the gem
+* DELETEs may now post entity bodies to allow spec-violate behavior similar to GETs (thanks @hobodave)
 
 ## v0.4
 
 ## v0.4.5 (pending, master branch)
 
+* If you pass a block to background request creation, the background request is yielded before being queued on the executor. This allows you to attach
+  on_success, etc handlers. This is a stopgap change that is backwards compatible with 0.4.x and will be changing in the 0.5.x release.
+
 ## v0.4.4
 
 * Manticore now treats post bodies with binary encodings as binary byte lists rather than strings with an encoding

data/Gemfile

@@ -9,4 +9,4 @@ gem "rspec-its"
 gem "httpclient", "~> 2.3"
 gem "rack", "~> 1.5"
 gem "rake-compiler"
-gem "gserver"
+gem "gserver"

data/LICENSE.txt

@@ -1,13 +1,4 @@
-Copyright (c) 2013 Chris Heald
-
-Some JARs distributed with this project are licensed under the Apache 2.0 License. See APACHE-LICENSE-2.0.txt for details:
-
-  lib/jar/commons-logging-1.1.3.jar
-  lib/jar/httpclient-4.3.2.jar
-  lib/jar/httpcore-4.3.1.jar
-  lib/jar/commons-codec-1.6.jar
-
-All other code distributed with this project is licensed under the MIT License as follows:
+Copyright (c) 2015 Chris Heald
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -136,36 +136,41 @@ internal CA, and would proxy all requests through an internal server.
 Creating pools is expensive, so you don't want to be doing it for each request. Instead, you should set up your pools once and then re-use them.
 Clients and their backing pools are thread-safe, so feel free to set them up once before you start performing parallel operations.
 
+### Background requests
+
+You might want to fire off requests without blocking your calling thread. You can do this with `Client#background`:
+
+```ruby
+response = client.background.get("http://google.com")
+                 .on_success {|response| puts response.code }
+response.call # The request is now running, but the calling thread isn't blocked. The on_success handler will be evaluated whenever
+              # the request completes.
+```
 
 ### Parallel execution
 
-Manticore can perform concurrent execution of multiple requests.
+Manticore can perform concurrent execution of multiple requests. In previous versions of Manticore, this was called "async". We now call these
+"parallel" or "batch" requests. `Client#async`, `Client#parallel`, and `Client#batch` are equivalent.
 
 ```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
-
-  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")
+# You can define response handlers on the not-yet-resolved response object:
+response = client.parallel.get("http://www.yahoo.com")
 response.on_success do |response|
   puts "The length of the Yahoo! homepage is #{response.body.length}"
 end
 
+response.on_failure do |response|
+  puts "http://www.nooooooooooooooo.com/"
+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!"}
+client.parallel.get("http://bing.com")
+  .on_success  {|r| puts r.code     }
+  .on_failure  {|e| puts "on noes!" }
+  .on_complete { puts "Job's done!" }
 
 client.execute!
 ```
@@ -175,36 +180,56 @@ client.execute!
 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`.
+1. Synchronous and parallel/batch responses are synchronously evaluted when you call an accessor on them, like `#body` or `#headers`, or invoke them with `#call`
+2. Synchronous and background responses which pass a handler block are evaluated immediately. Sync responses will block the calling thread until complete,
+   while background responses will not block the calling thread.
+3. Parallel/batch responses are evaluated when you call `Client#execute!`. Responses which have been previously evaluted by calling an accessor like `#body` or
+   which have been manually called with `#call` will not be re-requested.
+4. Background responses are evaluated when you call `#call` and return a `Future`, on which you can call `#get` to synchronously get the resolved response.
 
-As a result, with the exception of background requests, this allows you to attach handlers to synchronous
-and asynchronous responses in the same fashion:
+As a result, this allows you to attach handlers to synchronous, background, and parallel 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
+## Standard/sync requests
+response = client.get("http://google.com")
+response.on_success {|r| puts "Success!" }  # Because the response isn't running yet, we can attach a handler
+body = response.body                        # When you access information from the response, the request finally runs
+
+## Parallel requests
+response1 = client.parallel.get("http://google.com")
+response2 = client.parallel.get("http://yahoo.com")
+response1.on_success {|response| puts "Yay!" }
+response2.on_failure {|exception| puts "Whoops!" }
+client.execute!       # Nothing runs until we call Client#execute!
+body = response1.body # Now the responses are resolved and we can get information from them
+
+## Background requests
+request = client.background.get("http://google.com")
+request.on_success {|r| puts "Success!" }  # We can attach handlers before the request is kicked off
+future = request.call                      # We invoke #call on it to fire it off.
+response = future.get                      # You can get the Response via Future#get. This will block the calling thread until it resolves, though.
 ```
 
-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:
+If you want to immediately evaluate a request, you can either pass a handler block to it, or you can call `#call` to fire it off:
 
 ```ruby
 # This will evaluate immediately
-client.get("http://google.com") {r| r.body }
+client.get("http://google.com") {|r| r.body }
 
 # As will this, via explicit invocation of #call
 client.get("http://google.com").call
 ```
 
+For batch/parallel/async requests, a passed block will be treated as the on_success handler, but will not cause the
+request to be immediately invoked:
+
+```ruby
+# This will not evaluate yet
+client.batch.get("http://google.com") {|r| puts "Fetched Google" }
+# ...but now it does.
+client.execute!
+```
+
 ### Stubbing
 
 Manticore provides a stubbing interface somewhat similar to Typhoeus'
@@ -217,18 +242,18 @@ end
 client.clear_stubs!
 ```
 
-This works for async requests as well:
+This works for parallel/batch/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|
+client.parallel.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|
+client.parallel.get("http://yahoo.com").on_success do |response|
   response.should be_a Manticore::Response
 end
 client.clear_stubs!
@@ -243,10 +268,10 @@ client.respond_with(body: "body").get("http://google.com") do |response|
 end
 ```
 
-You can also chain proxies to, say, stub an async request:
+You can also chain proxies to, say, stub an parallel request:
 
 ```ruby
-response = client.async.respond_with(body: "response body").get("http://google.com")
+response = client.parallel.respond_with(body: "response body").get("http://google.com")
 client.execute!
 
 response.body.should == "response body"
@@ -266,17 +291,6 @@ end
 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
-```
-
 ### Faraday Adapter
 
 Manticore includes a Faraday adapter. To use it:

data/Rakefile

@@ -7,20 +7,24 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
 end
 task :default => [:generate_certs, :spec]
 
-require 'rake/javaextensiontask'
+# Download and vendor the jars needed
+require 'jar_installer'
+task :install_jars do
+  Jars::JarInstaller.new.send :do_install, true, true
+end
 
-# Dependency jars for the Kerrigan ext build
-jars = [
-  "#{ENV['MY_RUBY_HOME']}/lib/jruby.jar",
-  "lib/jar/httpcore-4.3.3.jar",
-  "lib/jar/httpclient-4.3.6.jar"
-]
+## Build the Manticore extensions into a jar. You may need to install_jars first
+# Dependency jars for the Manticore ext build
+require 'rake/javaextensiontask'
+jars = ["#{ENV['MY_RUBY_HOME']}/lib/jruby.jar"] + Dir.glob("lib/**/*.jar")
+jars.reject! {|j| j.match("manticore-ext") }
 Rake::JavaExtensionTask.new do |ext|
   ext.name = "manticore-ext"
-  ext.lib_dir = "lib/jar"
+  ext.lib_dir = "lib/org/manticore"
   ext.classpath = jars.map {|x| File.expand_path x}.join ':'
 end
 
+# Generate all the stuff we need for a full test run
 task :generate_certs do
   root = File.expand_path("../spec/ssl", __FILE__)
   openssl = `which openssl`.strip

data/ext/manticore/org/manticore/HttpDeleteWithEntity.java

@@ -0,0 +1,27 @@
+package org.manticore;
+
+import java.net.URI;
+import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
+
+public class HttpDeleteWithEntity extends HttpEntityEnclosingRequestBase {
+    public final static String METHOD_NAME = "DELETE";
+
+    public HttpDeleteWithEntity() {
+        super();
+    }
+
+    public HttpDeleteWithEntity(URI url) {
+        super();
+        setURI(url);
+    }
+
+    public HttpDeleteWithEntity(String url) {
+        super();
+        setURI(URI.create(url));
+    }
+
+    @Override
+    public String getMethod() {
+        return METHOD_NAME;
+    }
+}

data/ext/manticore/org/manticore/HttpGetWithEntity.java

@@ -1,17 +1,23 @@
 package org.manticore;
 
 import java.net.URI;
-import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
 
-public class HttpGetWithEntity extends HttpPost {
+public class HttpGetWithEntity extends HttpEntityEnclosingRequestBase {
     public final static String METHOD_NAME = "GET";
 
+    public HttpGetWithEntity() {
+        super();
+    }
+
     public HttpGetWithEntity(URI url) {
-        super(url);
+        super();
+        setURI(url);
     }
 
     public HttpGetWithEntity(String url) {
-        super(url);
+        super();
+        setURI(URI.create(url));
     }
 
     @Override

data/lib/manticore.rb

@@ -2,17 +2,8 @@ require 'java'
 require 'uri'
 require 'cgi'
 
-jars = ["httpcore-4.3.3", "httpclient-4.3.6", "commons-logging-1.1.3", "commons-codec-1.6.jar", "httpmime-4.3.6.jar"]
-jars.each do |jar|
-  begin
-    require_relative "./jar/#{jar}"
-  rescue LoadError
-    raise "Unable to load #{jar}; is there another version of it in your classpath?"
-  end
-end
-
-# 4.3.x
-require_relative "./jar/manticore-ext"
+require_relative "./manticore_jars.rb"
+require_relative "./org/manticore/manticore-ext"
 
 org.manticore.Manticore.new.load(JRuby.runtime, false)
 
@@ -57,4 +48,10 @@ module Manticore
 
   include Facade
   include_http_client
-end
+
+  def self.disable_httpcomponents_logging!
+    props = Java::JavaLang::System.properties
+    props.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog")
+    props.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "error")
+  end
+end

data/lib/manticore/client.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'singleton'
 require 'base64'
 
 module Manticore
@@ -87,6 +86,7 @@ module Manticore
     java_import "org.apache.http.HttpHost"
     java_import "javax.net.ssl.SSLContext"
     java_import "org.manticore.HttpGetWithEntity"
+    java_import "org.manticore.HttpDeleteWithEntity"
     java_import "org.apache.http.auth.UsernamePasswordCredentials"
 
     include ProxiesInterface
@@ -101,6 +101,8 @@ module Manticore
     DEFAULT_EXPECT_CONTINUE = false
     DEFAULT_STALE_CHECK     = false
 
+    attr_reader :client
+
     # Create a new HTTP client with a backing request pool. if you pass a block to the initializer, the underlying
     # {http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/impl/client/HttpClientBuilder.html HttpClientBuilder}
     # and {http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/client/config/RequestConfig.Builder.html RequestConfig.Builder}
@@ -134,6 +136,7 @@ module Manticore
     #                                                                            on GET, HEAD, PUT, DELETE, OPTIONS, and TRACE
     # @option options [boolean]         expect_continue            (false)     Enable support for HTTP 100
     # @option options [boolean]         stale_check                (false)     Enable support for stale connection checking. Adds overhead.
+    # @option options [integer]         check_connection_timeout   (15_000)    Connections that haven't been used in this many milliseconds will be validated before being used. Set to a negative number to disable.
     # @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'[, user: 'username@host', password: 'password']]]}
     # @option options [Hash]            proxy                                    Proxy host in form: {url:  'http://proxy.org:1234'[, user: 'username@host', password: 'password']]]}
@@ -249,7 +252,7 @@ module Manticore
     # @macro http_method_shared_sync
     def delete(url, options = {}, &block)
       options = treat_params_as_query(options)
-      request HttpDelete, url, options, &block
+      request HttpDeleteWithEntity, url, options, &block
     end
 
     # Perform a HTTP OPTIONS request
@@ -361,11 +364,11 @@ module Manticore
     def pool(options = {})
       @pool ||= begin
         @max_pool_size = options.fetch(:pool_max, DEFAULT_MAX_POOL_SIZE)
-        cm = pool_builder options
-        cm.set_default_max_per_route options.fetch(:pool_max_per_route, @max_pool_size)
-        cm.set_max_total @max_pool_size
-        IdleConnectionReaper.instance.monitor(cm)
-        cm
+        pool_builder(options).tap do |cm|
+          cm.set_validate_after_inactivity options.fetch(:check_connection_timeout, 15_000)
+          cm.set_default_max_per_route options.fetch(:pool_max_per_route, @max_pool_size)
+          cm.set_max_total @max_pool_size
+        end
       end
     end
 
@@ -377,37 +380,32 @@ module Manticore
 
     def request(klass, url, options, &block)
       req, context = request_from_options(klass, url, options)
-      if options.delete(:async)
-        async_request req, context
-      else
-        sync_request req, context, &block
+      async        = options.delete(:async)
+      background   = options.delete(:async_background)
+      create_executor_if_needed if (background || async)
+      response     = response_object_for(req, context, &block)
+
+      if async
+        @async_requests << response
+      elsif background
+        response.background = true
       end
-    end
 
-    def async_request(request, context)
-      create_executor_if_needed
-      response = response_object_for(@client, request, context)
-      @async_requests << response
-      response
-    end
-
-    def sync_request(request, context, &block)
-      response = response_object_for(@client, request, context, &block)
-      if block_given?
+      if block_given? && (background || !async)
         response.call
       else
         response
       end
     end
 
-    def response_object_for(client, request, context, &block)
+    def response_object_for(request, context, &block)
       request_uri = request.getURI.to_s
 
       match_key = @stubs.keys.find { |k| request_uri.match(k) }
       if match_key
-        StubbedResponse.new(client, request, context, &block).stub( @stubs[match_key] )
+        StubbedResponse.new(self, request, context, &block).stub( @stubs[match_key] )
       else
-        Response.new(client, request, context, &block)
+        Response.new(self, request, context, &block)
       end
     end
 
@@ -421,8 +419,7 @@ module Manticore
     def request_from_options(klass, url, options)
       req = klass.new uri_from_url_and_options(url, options).to_s
 
-      if ( options[:params] || options[:body] || options[:entity]) &&
-         ( req.instance_of?(HttpPost) || req.instance_of?(HttpPatch) || req.instance_of?(HttpPut) || req.instance_of?(HttpGetWithEntity))
+      if ( options[:params] || options[:body] || options[:entity]) && req.kind_of?(HttpEntityEnclosingRequestBase)
         if options[:params]
           pairs = struct_to_name_value_pairs(options[:params])
           encoding = minimum_encoding_for options[:params].to_s
@@ -662,29 +659,4 @@ module Manticore
       super(exception, executionCount, context)
     end
   end
-
-  class IdleConnectionReaper
-    include Singleton
-    def initialize
-      @mutex = Mutex.new
-      @pools = []
-      @running = Java::JavaUtilConcurrentAtomic::AtomicBoolean.new(true)
-      @thread = Thread.new do
-        while @running.get
-          @mutex.synchronize { @pools.each(&:closeExpiredConnections) }
-          sleep 5000
-        end
-      end
-      at_exit { shutdown }
-    end
-
-    def monitor(pool)
-      @mutex.synchronize { @pools << pool }
-    end
-
-    def shutdown
-      @running.set(false)
-      @thread.wakeup
-    end
-  end
 end

data/lib/manticore/client/proxies.rb

@@ -9,6 +9,8 @@ module Manticore
       def async
         AsyncProxy.new(self)
       end
+      alias_method :parallel, :async
+      alias_method :batch, :async
 
       # Causes the next request to be made immediately in the background
       def background
@@ -48,8 +50,7 @@ module Manticore
     class BackgroundProxy < BaseProxy
       %w(get put head post delete 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
+          @client.send(func, url, options.merge(async_background: true), &block)
         end
       end
     end

data/lib/manticore/facade.rb

@@ -24,17 +24,26 @@ module Manticore
       # @param  options Hash Options to be passed to the underlying shared client, if it has not been created yet.
       # @return nil
       def include_http_client(options = {}, &block)
-        if shared_pool = options.delete(:shared_pool)
-          @manticore_facade = Manticore.instance_variable_get("@manticore_facade")
-        else
-          @manticore_facade = Manticore::Client.new(options, &block)
-        end
+        @__manticore_facade_options = [options, block]
         class << self
           extend Forwardable
-          def_delegators "@manticore_facade", :get, :head, :put, :post, :delete, :options, :patch
+          def_delegators "__manticore_facade", :get, :head, :put, :post, :delete, :options, :patch, :http
         end
         nil
       end
+
+      private
+
+      def __manticore_facade
+        @manticore_facade ||= begin
+          options, block = *@__manticore_facade_options
+          if shared_pool = options.delete(:shared_pool)
+            Manticore.send(:__manticore_facade)
+          else
+            Manticore::Client.new(options, &block)
+          end
+        end
+      end
     end
   end
 end

data/lib/manticore/response.rb

@@ -20,10 +20,12 @@ module Manticore
     include ResponseHandler
     include Callable
 
-    attr_reader :context, :request, :callback_result, :called
+    attr_accessor :background
+    attr_reader :context, :request, :callback_result, :called, :future
 
     # Creates a new Response
     #
+    # @param  client             [Manticore::Client] The client that was used to create this response
     # @param  request            [HttpRequestBase] The underlying request object
     # @param  context            [HttpContext] The underlying HttpContext
     def initialize(client, request, context, &block)
@@ -41,10 +43,11 @@ module Manticore
     # Implementation of Callable#call
     # Used by Manticore::Client to invoke the request tied to this response.
     def call
+      return background! if @background
       raise "Already called" if @called
       @called = true
       begin
-        @client.execute @request, self, @context
+        @client.client.execute @request, self, @context
       rescue Java::JavaNet::SocketTimeoutException => e
         ex = Manticore::SocketTimeout
       rescue Java::OrgApacheHttpConn::ConnectTimeoutException => e
@@ -76,10 +79,6 @@ module Manticore
       end
     end
 
-    def fire_and_forget
-      @client.executor.submit self
-    end
-
     # Fetch the final resolved URL for this response. Will call the request if it has not been called yet.
     #
     # @return [String]
@@ -200,7 +199,7 @@ module Manticore
     alias_method :failure, :on_failure
     alias_method :fail,    :on_failure
 
-    # Set handler for cancelled requests
+    # Set handler for cancelled requests. NB: Not actually used right now?
     # @param block Proc which will be invoked on a on a cancelled response.
     #
     # @return self
@@ -212,9 +211,9 @@ module Manticore
     alias_method :cancellation,    :on_cancelled
     alias_method :on_cancellation, :on_cancelled
 
-    # Set handler for cancelled requests
-    # @param block Proc which will be invoked on a on a cancelled response.
-    #
+    # Set handler for completed requests
+    # @param block Proc which will be invoked on a on a completed response. This handler will be called
+    #                   regardless of request success/failure.
     # @return self
     def on_complete(&block)
       @handlers[:complete] = Array(@handlers[:complete]).compact + [block]
@@ -230,6 +229,11 @@ module Manticore
 
     private
 
+    def background!
+      @background = false
+      @future ||= @client.executor.java_method(:submit, [java.util.concurrent.Callable.java_class]).call(self)
+    end
+
     # Implementation of {http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/client/ResponseHandler.html#handleResponse(org.apache.http.HttpResponse) ResponseHandler#handleResponse}
     # @param  response [Response] The underlying Java Response object
     def handleResponse(response)
@@ -242,7 +246,11 @@ module Manticore
     end
 
     def call_once
+      is_background = @background
       call unless called?
+      # If this is a background request, then we don't want to allow the usage of sync methods, as it's probably a semantic error. We could resolve the future
+      # but that'll probably result in blocking foreground threads unintentionally. Fail loudly.
+      raise RuntimeError.new("Cannot call synchronous methods on a background response. Use an on_success handler instead.") if is_background && @future
       @called = true
     end
 

data/lib/manticore/version.rb

@@ -1,3 +1,3 @@
 module Manticore
-  VERSION = "0.4.4"
+  VERSION = "0.5.0"
 end

data/lib/manticore_jars.rb

@@ -0,0 +1,8 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+require 'jar_dependencies'
+
+require_jar( 'org.apache.httpcomponents', 'httpclient', '4.5' )
+require_jar( 'org.apache.httpcomponents', 'httpcore', '4.4.1' )
+require_jar( 'commons-codec', 'commons-codec', '1.9' )
+require_jar( 'commons-logging', 'commons-logging', '1.2' )
+require_jar( 'org.apache.httpcomponents', 'httpmime', '4.5' )

data/manticore.gemspec

@@ -27,4 +27,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "jar-dependencies"
+  spec.requirements << "jar org.apache.httpcomponents:httpclient, 4.5"
+  spec.requirements << "jar org.apache.httpcomponents:httpmime, 4.5"
 end

data/spec/manticore/client_proxy_spec.rb

@@ -75,7 +75,7 @@ describe Manticore::Client do
   describe Manticore::Client::BackgroundProxy do
     it "does not block execution" do
       anchor = Time.now.to_f
-      future = client.background.get("http://localhost:55441/?sleep=1.5")
+      future = client.background.get("http://localhost:55441/?sleep=1.5").call
       expect(Time.now.to_f - anchor).to be < 1.0
 
       response = future.get
@@ -83,10 +83,25 @@ describe Manticore::Client do
       expect(response.body).to match(/sleep=1.5/)
     end
 
-    it "returns a future" do
+    it "returns a response proxy" do
       response = client.background.get("http://localhost:55441/")
-      expect(response).to be_a Java::JavaUtilConcurrent::FutureTask
-      response.get
+      expect(response).to be_a Manticore::Response
+
+      success = false
+      response.on_success do
+        success = true
+      end
+
+      response.call.get
+      expect(success).to eq true
+    end
+
+    describe "#call" do
+      it "returns a future" do
+        response = client.background.get("http://localhost:55441/").call
+        expect(response).to be_a Java::JavaUtilConcurrent::FutureTask
+        response.get
+      end
     end
   end
 end

data/spec/manticore/client_spec.rb

@@ -462,6 +462,18 @@ describe Manticore::Client do
     end
   end
 
+  describe "#delete" do
+    it "works" do
+      response = client.delete(local_server)
+      expect(JSON.load(response.body)["method"]).to eq "DELETE"
+    end
+
+    it "sends a body" do
+      response = client.delete(local_server, body: "This is a delete body")
+      expect(JSON.load(response.body)["body"]).to eq "This is a delete body"
+    end
+  end
+
   describe "#head" do
     it "works" do
       response = client.head(local_server)
@@ -634,15 +646,18 @@ describe Manticore::Client do
       @server = Thread.new do
         loop do
           client = @socket.accept
-          client.puts([
-            "HTTP/1.1 200 OK",
-            "Keep-Alive: timeout=3000",
-            "Connection: Keep-Alive",
-            "Content-Length: 6",
-            "",
-            "Hello!"
-          ].join("\n"))
-          client.close
+          begin
+            client.puts([
+              "HTTP/1.1 200 OK",
+              "Keep-Alive: timeout=3000",
+              "Connection: Keep-Alive",
+              "Content-Length: 6",
+              "",
+              "Hello!"
+            ].join("\n"))
+            client.close
+          rescue StandardError => e
+          end
         end
       end
     end
@@ -707,6 +722,70 @@ describe Manticore::Client do
     end
   end
 
+  describe "request types:" do
+    describe "sync" do
+      it "returns a response" do
+        expect(client.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "evaluates immediately when given a block" do
+        called = false
+        expect { client.get(local_server) { called = true } }.to change { called }.to(true)
+      end
+
+      it "can be evaluated synchronously on-demand" do
+        expect(client.get(local_server).body).to be_a String
+      end
+    end
+
+    describe "async" do
+      it "returns a response" do
+        expect(client.async.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "works with `parallel`" do
+        expect(client.parallel.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "works with `batch`" do
+        expect(client.parallel.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "does not evaluate immediately when given a block" do
+        called = false
+        expect { client.async.get(local_server) { called = true }; sleep 0.5 }.to_not change { called }
+      end
+
+      it "can be evaluated synchronously on-demand" do
+        expect(client.async.get(local_server).body).to be_a String
+      end
+    end
+
+    describe "background" do
+      it "returns a response" do
+        expect( client.background.get(local_server) ).to be_a Manticore::Response
+      end
+
+      it "has the background flag set" do
+        expect( client.background.get(local_server).background ).to eq true
+      end
+
+      it "returns a future when called" do
+        expect( client.background.get(local_server).call ).to be_a Java::JavaUtilConcurrent::FutureTask
+      end
+
+      it "evaluates immediately when given a block" do
+        called = false
+        expect { (client.background.get(local_server) { called = true }).get }.to change { called }.to(true)
+      end
+
+      it "raises an exception when a sync method is called on it" do
+        called = false
+        expect { client.background.get(local_server).body }.to raise_exception(RuntimeError)
+      end
+    end
+  end
+
   def get_connection(client, uri, &block)
     java_import "java.util.concurrent.TimeUnit"
     host = URI.parse(uri).host

data/spec/manticore/facade_spec.rb

@@ -22,13 +22,18 @@ describe Manticore::Facade do
     end
 
     it "does not use the shared client by default" do
-      expect(extended_class.instance_variable_get("@manticore_facade").object_id).to_not eq \
-        Manticore.instance_variable_get("@manticore_facade").object_id
+      expect(extended_class.send(:__manticore_facade).object_id).to_not eq \
+        Manticore.send(:__manticore_facade).object_id
     end
 
     it "is able to use the shared client" do
-      expect(extended_shared_class.instance_variable_get("@manticore_facade").object_id).to eq \
-        Manticore.instance_variable_get("@manticore_facade").object_id
+      expect(extended_shared_class.send(:__manticore_facade).object_id).to eq \
+        Manticore.send(:__manticore_facade).object_id
+    end
+
+    it "should work with #http" do
+      result = JSON.parse extended_class.http(:get, local_server).body
+      expect(result["method"]).to eq "GET"
     end
   end
 

data/spec/manticore/response_spec.rb

@@ -46,4 +46,45 @@ describe Manticore::Response do
       expect { client.get(local_server).call rescue nil }.to_not change { client.pool_stats[:available] }
     end
   end
+
+  context "given a success handler" do
+    let(:responses) { {} }
+    let(:response) do
+      client.get(url)
+        .on_success {|resp| responses[:success] = true }
+        .on_failure {responses[:failure]        = true }
+        .on_complete {responses[:complete]      = true }
+    end
+
+    context "a succeeded request" do
+      let(:url) { local_server }
+      it "runs the success handler" do
+        expect { response.call }.to change { responses[:success] }.to true
+      end
+
+      it "does not run the failure handler" do
+        expect { response.call }.to_not change { responses[:failure] }
+      end
+
+      it "runs the completed handler" do
+        expect { response.call }.to change { responses[:complete] }.to true
+      end
+    end
+
+    context "a failed request" do
+      let(:url) { local_server("/failearly") }
+      it "does not run the success handler" do
+        expect { response.call }.to_not change { responses[:success] }
+      end
+
+      it "runs the failure handler" do
+        expect { response.call }.to change { responses[:failure] }.to true
+      end
+
+      it "runs the completed handler" do
+        expect { response.call }.to change { responses[:complete] }.to true
+      end
+    end
+
+  end
 end

data/spec/spec_helper.rb

@@ -8,6 +8,7 @@ require 'webrick'
 require 'webrick/https'
 require 'openssl'
 require 'rspec/its'
+require 'logger'
 
 PORT = 55441
 
@@ -31,7 +32,7 @@ end
 def start_server(port = PORT)
   @servers ||= {}
   @servers[port] = Thread.new {
-    Net::HTTP::Server.run(port: port) do |request, stream|
+    Net::HTTP::Server.run(port: port, log: Logger.new("/dev/null")) do |request, stream|
 
       query = Rack::Utils.parse_query(request[:uri][:query].to_s)
       if query["sleep"]
@@ -72,9 +73,9 @@ def start_server(port = PORT)
         if request[:headers]["Accept-Encoding"] && request[:headers]["Accept-Encoding"].match("gzip")
           out = StringIO.new('', "w")
           io = Zlib::GzipWriter.new(out, 2)
-         
+
           request[:body] = Base64.encode64(request[:body]) if request[:headers]["X-Base64"]
-          
+
           io.write JSON.dump(request)
           io.close
           payload = out.string
@@ -127,6 +128,8 @@ RSpec.configure do |c|
     start_server 55442
     start_ssl_server 55444
     start_ssl_server 55445, :SSLVerifyClient => OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT, :SSLCACertificateFile => File.expand_path("../ssl/root-ca.crt", __FILE__)
+
+    Manticore.disable_httpcomponents_logging!
   }
 
   c.after(:suite)  { stop_servers }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: manticore
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: java
 authors:
 - Chris Heald
@@ -30,12 +30,12 @@ cert_chain:
   cnyabLOcGIKZNxvnSfwOuCBnjgoSOyJi/n48n1s+OPB/OmPJoWmhKu2DO4sUb4+K
   /3Mhp5UWSl9SmDR1
   -----END CERTIFICATE-----
-date: 2015-08-20 00:00:00.000000000 Z
+date: 2015-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
   name: bundler
@@ -43,13 +43,13 @@ dependencies:
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   name: rake
@@ -57,7 +57,21 @@ dependencies:
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: jar-dependencies
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Manticore is an HTTP client built on the Apache HttpCore components
@@ -67,24 +81,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - APACHE-LICENSE-2.0.txt
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- ext/manticore/org/manticore/HttpDeleteWithEntity.java
 - ext/manticore/org/manticore/HttpGetWithEntity.java
 - ext/manticore/org/manticore/Manticore.java
 - gem-public_cert.pem
 - lib/faraday/adapter/manticore.rb
-- lib/jar/commons-codec-1.6.jar
-- lib/jar/commons-logging-1.1.3.jar
-- lib/jar/httpclient-4.3.6.jar
-- lib/jar/httpcore-4.3.3.jar
-- lib/jar/httpmime-4.3.6.jar
-- lib/jar/manticore-ext.jar
 - lib/manticore.rb
 - lib/manticore/client.rb
 - lib/manticore/client/proxies.rb
@@ -94,6 +103,8 @@ files:
 - lib/manticore/response.rb
 - lib/manticore/stubbed_response.rb
 - lib/manticore/version.rb
+- lib/manticore_jars.rb
+- lib/org/manticore/manticore-ext.jar
 - manticore.gemspec
 - spec/manticore/client_proxy_spec.rb
 - spec/manticore/client_spec.rb
@@ -113,15 +124,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-requirements: []
+requirements:
+- jar org.apache.httpcomponents:httpclient, 4.5
+- jar org.apache.httpcomponents:httpmime, 4.5
 rubyforge_project:
 rubygems_version: 2.4.8
 signing_key:
@@ -136,4 +149,3 @@ test_files:
 - spec/manticore/stubbed_response_spec.rb
 - spec/spec_helper.rb
 - spec/ssl/.keepme
-has_rdoc: