manticore 0.4.2-java → 0.4.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e81862fe8dbfe629fdc9dbe09504e2214b3de702
-  data.tar.gz: 5b840aa1a038b4eab593e248b3a679ec6d16fc67
+  metadata.gz: 1e663f9b19e305371f23a33ca105cf960255b53a
+  data.tar.gz: 6c0dd62a760f11460cf565949632e8dbfa77d117
 SHA512:
-  metadata.gz: 9e5e970a68358d71776af2f4fd0b7e13bf3a13dac3d2beb2c860882301a4fe4cfbb1dae42fbff1ca4bc6ff8bff042237370e243fe804c0b1547f6f370c1d3f30
-  data.tar.gz: 5f3122739a100067e60c2817476ec75af8af109e1ef4ece4b75fed4e695d51d39c018a1fedc3b71a663bcf21eedc36a1d50c614a4d9dbb749c33fcbbd6c54784
+  metadata.gz: f0f65941a497dfa2254d4859bf8528cfc0b299f280a6564556aa3a9f08de4d634a1ef3f488ac467b12ace46a5637a793a65a63ffa290300551019f7b49fd0d1f
+  data.tar.gz: 3e5766be83ff90fc7bab9b5becdc5801156a1fe06ead3f3dd679ee686c8b9c1994ba12c04f7bb450f6758b9d21b21f7e67f41f979b083ce421feecf721b8880e

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 rvm:
-  - jruby
+  - jruby-1.7
+  - jruby-9.0.0.0
 jdk:
   - oraclejdk8
   - oraclejdk7

data/CHANGELOG.md

@@ -1,6 +1,19 @@
+## v0.5
+
+### v0.5.0 (pending)
+
 ## v0.4
 
-### v0.4.3 (pending)
+### v0.4.3
+
+* Manticore no longer automatically retries all request types. Only non-idempotent requests will be automatically retried by default.
+* added the `:retry_non_idempotent` [bool] option, which instructs Manticore to automatically retry all request types, rather than just idempotent request types
+* .pfx files are automatically recognized as PKCS12 stores
+* Improved StubbedResponse's mimicry of Response
+* Minor improvments to the Faraday adapter
+* Added an option for eager auth, which instructs Manticore to present basic auth credentials on initial request, rather than being challenged for them. You should
+  only use this if you have a specific need for it, as it may be a security concern otherwise.
+* Manticore now cleans up the stale connection reaper thread at_exit. This may resolve memory leaks in servlet contexts.
 
 ### v0.4.2
 
@@ -10,7 +23,7 @@
 
 ### v0.4.1
 
-* Add support for ssl[:ca_file], ssl[:client_cert], and ssl[:client_key], to emulate OpenSSL features in other Ruby HTTP clients
+* Add support for `ssl[:ca_file]`, `ssl[:client_cert]`, and `ssl[:client_key]`, to emulate OpenSSL features in other Ruby HTTP clients
 * Integrate Faraday adapter for Manticore
 
 ### v0.4.0

data/Gemfile

@@ -4,7 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 gem "net-http-server", "~> 0.2"
-gem "rspec", "~> 2.0"
+gem "rspec", "~> 3.0"
 gem "rspec-its"
 gem "httpclient", "~> 2.3"
 gem "rack", "~> 1.5"

data/README.md

@@ -20,7 +20,7 @@ Or install it yourself as:
 
 ## Documentation
 
-  Documentation is available [at rubydoc.info](http://rubydoc.info/github/cheald/manticore/master/frames).
+  Documentation is available [at rubydoc.info](http://www.rubydoc.info/github/cheald/manticore/master/Manticore/Client).
 
 ## Performance
 
@@ -66,7 +66,7 @@ end
 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:
+Mixing the client into a class will create a new pool. If you want to share a single pool between clients, specify the `shared_pool` option:
 
 ```ruby
 class MyClient
@@ -111,7 +111,7 @@ end
 
 You've seen "pools" mentioned a few times. Manticore creates and configures a [PoolingHttpClientConnectionManager](http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/impl/conn/PoolingHttpClientConnectionManager.html)
 which all requests are run through. The advantage here is that configuration and setup is performed once, and this lets clients take advantage of things like keepalive,
-per-route concurrency limits, and other neat things. In general, you should create one `Manticore::Client` instance pe unique configuration needed. For example, you might have an app that performs 2 functions:
+per-route concurrency limits, and other neat things. In general, you should create one `Manticore::Client` instance per unique configuration needed. For example, you might have an app that performs 2 functions:
 
 1. General HTTP requesting from the internet-at-large
 2. Communication with a backend service over SSL, using a custom trust store

data/lib/faraday/adapter/manticore.rb

@@ -20,6 +20,11 @@ module Faraday
         ParallelManager.new
       end
 
+      def initialize(app, connection_options = {})
+        @connection_options = connection_options
+        super(app)
+      end
+
       def client(env)
         @client ||= begin
           opts = {}
@@ -30,6 +35,11 @@ module Faraday
             opts[:ssl][:client_cert] = ssl[:client_cert]
             opts[:ssl][:client_key]  = ssl[:client_key]
           end
+          conn_opts = @connection_options.dup
+          if conn_opts.key?(:ssl)
+            (opts[:ssl] ||= {}).merge! conn_opts.delete(:ssl)
+          end
+          opts.merge! conn_opts
           ::Manticore::Client.new(opts)
         end
       end
@@ -78,7 +88,7 @@ module Faraday
           when ::Manticore::SocketException, ::Java::JavaUtilConcurrent::ExecutionException
             raise ConnectionFailed, err
           when ::Manticore::ClientProtocolException
-            raise Faraday::SSLError, err
+            raise Faraday::ClientError, err
           else
             raise err
           end

data/lib/manticore/client.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'singleton'
 require 'base64'
 
 module Manticore
@@ -15,6 +16,12 @@ module Manticore
   #   @option options [Integer]  request_timeout    Request-specific request timeout
   #   @option options [Integer]  max_redirects      Request-specific maximum redirect limit
   #   @option options [Boolean]  follow_redirects   Specify whether this request should follow redirects
+  #   @option options [Hash]     auth               Specify authentication for the request
+  #   @option options [String]   auth[:user]        Username to auth with
+  #   @option options [String]   auth[:password]    Password to auth with
+  #   @option options [Boolean]  auth[:eager]       Eagerly offer the Authorization header before the server challenges for it.
+  #                                                     You should not use this unless you know you specifically need it, as misuse
+  #                                                     of it can leak user credentials.
   #
   # @!macro [new] http_request_exceptions
   #   @raise [Manticore::Timeout] on socket, connection, or response timeout
@@ -62,6 +69,7 @@ module Manticore
     include_package "org.apache.http.impl"
     include_package "org.apache.http.impl.client"
     include_package "org.apache.http.impl.conn"
+    include_package "org.apache.http.impl.auth"
     include_package "org.apache.http.entity"
     include_package "org.apache.http.message"
     include_package "org.apache.http.params"
@@ -119,15 +127,15 @@ module Manticore
     # @option options [integer]         request_timeout            (60)        Sets the timeout for a given request. Raises Manticore::Timeout on failure.
     # @option options [integer]         max_redirects              (5)         Sets the maximum number of redirects to follow.
     # @option options [integer]         automatic_retries          (3)         Sets the number of times the client will automatically retry failed requests.
+    # @option options [boolean]         retry_non_idempotent       (false)     If true, Manticore will automatically retry failed requests with non-idempotent verbs. Otherwise, it only automatically retries
+    #                                                                            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 [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']]]}
     # @option options [URI]             proxy                                    Proxy host as a URI object
-    # @option options [Boolean/Fixnum]  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.
+    # @option options [Boolean]         keepalive                  (true)      Whether to allow connections to be reused. Defaults to true.
     # @option options [Hash]            ssl                                        Hash of options for configuring SSL
     # @option options [Array<String>]   ssl[:protocols]            (nil)       A list of protocols that Manticore should accept
     # @option options [Array<String>]   ssl[:cipher_suites]        (nil)       A list of cipher suites that Manticore should accept
@@ -155,19 +163,7 @@ module Manticore
       builder.disable_content_compression if options.fetch(:compression, true) == false
       builder.set_proxy get_proxy_host(options[:proxy]) if options.key?(:proxy)
 
-      builder.set_retry_handler do |exception, executionCount, context|
-        if (executionCount > options.fetch(:automatic_retries, 3))
-          false
-        else
-          case exception
-          when Java::OrgApacheHttp::NoHttpResponseException, Java::JavaNet::SocketException
-            context.setAttribute "retryCount", executionCount
-            true
-          else
-            false
-          end
-        end
-      end
+      builder.set_retry_handler LoggingStandardRetryHandler.new options.fetch(:automatic_retries, 3), options.fetch(:retry_non_idempotent, false)
 
       # http://hc.apache.org/httpcomponents-client-ga/tutorial/html/advanced.html#stateful_conn
       # By default this is used to prevent different contexts from accessing SSL data
@@ -362,13 +358,7 @@ module Manticore
         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
-
-        Thread.new {
-          loop {
-            cm.closeExpiredConnections
-            sleep 5000
-          }
-        }
+        IdleConnectionReaper.instance.monitor(cm)
         cm
       end
     end
@@ -468,7 +458,7 @@ module Manticore
 
       context = HttpClientContext.new
       proxy_user = req_options[:proxy].is_a?(Hash) && (req_options[:proxy][:user] || req_options[:proxy][:username])
-      auth_from_options(req_options, context) if req_options.key?(:auth) || proxy_user
+      auth_from_options(req, req_options, context) if req_options.key?(:auth) || proxy_user
 
       if @use_cookies == :per_request
         store = BasicCookieStore.new
@@ -501,7 +491,7 @@ module Manticore
       end
     end
 
-    def auth_from_options(options, context)
+    def auth_from_options(req, options, context)
       proxy = options.fetch(:proxy, {})
       if options[:auth] || proxy[:user] || proxy[:username]
         provider = BasicCredentialsProvider.new
@@ -509,6 +499,16 @@ module Manticore
           username = options[:auth][:user] || options[:auth][:username]
           password = options[:auth][:pass] || options[:auth][:password]
           provider.set_credentials AuthScope::ANY, UsernamePasswordCredentials.new(username, password)
+
+          if options[:auth][:eager]
+            uri = URI.parse req.uri.to_string
+            target = HttpHost.new(uri.host, uri.port, uri.scheme)
+            scheme = BasicScheme.new
+
+            cache = BasicAuthCache.new
+            cache.put target, scheme
+            context.set_auth_cache cache
+          end
         end
 
         if proxy[:user] || proxy[:username]
@@ -634,11 +634,43 @@ module Manticore
     end
 
     def guess_store_type(filename)
-      if filename.end_with?(".p12")
+      if filename.end_with?(".p12") || filename.end_with?(".pfx")
         "pkcs12"
       else
         KeyStore.get_default_type
       end
     end
   end
+
+  class LoggingStandardRetryHandler < Java::OrgApacheHttpImplClient::StandardHttpRequestRetryHandler
+    def retryRequest(exception, executionCount, context)
+      context.setAttribute "retryCount", executionCount
+      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/stubbed_response.rb

@@ -40,7 +40,7 @@ module Manticore
 
       stubs[:headers] ||= {}
       stubs[:headers] = Hash[*stubs[:headers].flat_map {|k, v| [k.downcase, v] }]
-      stubs[:headers]["content-length"] = stubs[:body].length if stubs.key?(:body)
+      stubs[:headers]["content-length"] = stubs[:body].length.to_s if stubs.key?(:body)
       @stubs = stubs
 
       self
@@ -57,13 +57,17 @@ module Manticore
     # @return [String] The final URL
     def final_url
       call_once
-      @headers["location"]
+      @headers["location"] || @request.getURI.to_string
     end
 
     # Returns the stubbed body of this response.
-    def body
+    def body(&block)
       call_once
-      @body
+      if block_given?
+        yield body
+      else
+        @body
+      end
     end
     alias_method :read_body, :body
 
@@ -87,7 +91,7 @@ module Manticore
         @cookies[c.name] ||= []
         @cookies[c.name] << c
       end
-      @handlers[:success].call(self)
+      @callback_result = @handlers[:success].call(self)
       self
     end
 

data/lib/manticore/version.rb

@@ -1,3 +1,3 @@
 module Manticore
-  VERSION = "0.4.2"
+  VERSION = "0.4.3"
 end

data/spec/manticore/client_proxy_spec.rb

@@ -4,38 +4,38 @@ describe Manticore::Client do
 
   describe Manticore::Client::StubProxy do
     describe "#respond_with" do
-      it "should respond with a stubbed response" do
+      it "responds with a stubbed response" do
         client.respond_with(body: "body", code: 200).get(local_server).on_success do |response|
-          response.should be_a Manticore::StubbedResponse
-          response.body.should == "body"
-          response.code.should == 200
+          expect(response).to be_a Manticore::StubbedResponse
+          expect(response.body).to eq "body"
+          expect(response.code).to eq 200
         end
       end
 
       context "for synchronous requests" do
-        it "should respond only stub the next subsequent response" do
+        it "responds only stub the next subsequent response" do
           stub = client.respond_with(body: "body", code: 200)
 
           stub.get(local_server) do |response|
-            response.should be_a Manticore::StubbedResponse
+            expect(response).to be_a Manticore::StubbedResponse
           end
 
           stub.get(local_server) do |response|
-            response.should be_a Manticore::Response
+            expect(response).to be_a Manticore::Response
           end
         end
       end
 
       context "for synchronous requests" do
-        it "should respond only stub the next subsequent response" do
+        it "responds only stub the next subsequent response" do
           stub = client.respond_with(body: "body", code: 200)
 
           stub.async.get(local_server).on_success do |response|
-            response.should be_a Manticore::StubbedResponse
+            expect(response).to be_a Manticore::StubbedResponse
           end
 
           stub.async.get(local_server).on_success do |response|
-            response.should be_a Manticore::Response
+            expect(response).to be_a Manticore::Response
           end
 
           client.execute!
@@ -45,17 +45,17 @@ describe Manticore::Client do
   end
 
   describe Manticore::Client::AsyncProxy do
-    it "should not make a request until execute is called" do
+    it "does not make a request until execute is called" do
       anchor = Time.now.to_f
       client.async.get("http://localhost:55441/?sleep=1.6")
-      (Time.now.to_f - anchor).should < 1.0
+      expect(Time.now.to_f - anchor).to be < 1.0
 
       anchor = Time.now.to_f
       client.execute!
-      (Time.now.to_f - anchor).should > 1.0
+      expect(Time.now.to_f - anchor).to be > 1.0
     end
 
-    it "should return the response object, which may then have handlers attached" do
+    it "returns the response object, which may then have handlers attached" do
       response = client.async.get("http://localhost:55441/")
       success = false
       response.on_success do
@@ -63,29 +63,29 @@ describe Manticore::Client do
       end
 
       client.execute!
-      success.should == true
+      expect(success).to eq true
     end
 
     it "can chain handlers" do
       client.async.get("http://localhost:55441/").on_success {|r| r.code }
-      client.execute!.map(&:callback_result).should == [200]
+      expect(client.execute!.map(&:callback_result)).to eq [200]
     end
   end
 
   describe Manticore::Client::BackgroundProxy do
-    it "should not block execution" do
+    it "does not block execution" do
       anchor = Time.now.to_f
       future = client.background.get("http://localhost:55441/?sleep=1.5")
-      (Time.now.to_f - anchor).should < 1.0
+      expect(Time.now.to_f - anchor).to be < 1.0
 
       response = future.get
-      (Time.now.to_f - anchor).should > 1.0
-      response.body.should match(/sleep=1.5/)
+      expect(Time.now.to_f - anchor).to be > 1.0
+      expect(response.body).to match(/sleep=1.5/)
     end
 
-    it "should return a future" do
+    it "returns a future" do
       response = client.background.get("http://localhost:55441/")
-      response.should be_a Java::JavaUtilConcurrent::FutureTask
+      expect(response).to be_a Java::JavaUtilConcurrent::FutureTask
       response.get
     end
   end