manticore 0.6.0-java → 0.7.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: aaec2b636e38b91767b212d83f2519c7e52ed085
-  data.tar.gz: 83eda4139c8cad24ccff8f9c022d5b4a8a9e7778
+SHA256:
+  metadata.gz: 508b2d2c3ce9fc25ca2ac915954807783cc8266aac23936a6896d103121a2f0c
+  data.tar.gz: a8ac97bd7fb22df23ac164d5f06f3a35c926d9eac57ae7bfb8e84c0c8d9e7907
 SHA512:
-  metadata.gz: 9e60fe0524842aaba68b508587ef4928db16c11fbbfcdd5b29c2453d1175e6edd79322ec4068c18e921eea3f7e021d5a5a9b523e46ad12aeed5e7668c6920b1d
-  data.tar.gz: 90c45bbc808cfeeac2b79685eed88162092fe8a73c81ca928f9c81309b10897a02c0ec2e88866ab1ef97baeeb884df85a595e48916c6d63cc2c925307cc4a2bc
+  metadata.gz: 56a60c747c187ddd1255e5da7cbc2ad78570c2ebf5390841298f45366133b48c857df8ac7b7b8bdbbb5194546e3b3112a8c08b5109c66a1299f6fe787ae890fc
+  data.tar.gz: 78e29e767486b820f1d1a280ae4db04b1ad33eccb7da7538bae9e48116305b44d069dc13ee322484146f9cce28b6edf71e868d73be8e075957404c50a99416eb

data/.gitlab-ci.yml

@@ -0,0 +1,42 @@
+.default: &default
+  variables:
+    TERM: xterm-256color
+    JRUBY_OPTS: --debug
+  cache:
+    paths:
+      - bundler --path vendor/bundle
+      - $HOME/.m2
+  before_script:
+    - apt update && apt install -y git
+    - gem install ruby-maven
+    - bundle install --path vendor/bundle
+  script:
+    - bundle exec rake
+
+test jruby-9.2:
+  <<: *default
+  image: jruby:9.2
+  artifacts:
+    expire_in: 3 days
+    paths:
+      - coverage
+
+test jruby-9.1:
+  <<: *default
+  image: jruby:9.1
+
+test jruby-1.7:
+  <<: *default
+  image: jruby:1.7
+
+pages:
+  stage: deploy
+  only:
+    - master
+  artifacts:
+    expire_in: 3 days
+    paths:
+      - public
+  script:
+    - mkdir -p public
+    - mv coverage/ public/coverage/

data/.travis.yml

@@ -1,22 +1,20 @@
+dist: xenial
 language: ruby
-sudo: false
 cache:
   - bundler
   - directories:
     - $HOME/.m2
 rvm:
-  - jruby-1.7
-  - jruby-9.0.5.0
+  - jruby-9.1.17.0 # Ruby 2.3
+  - jruby-9.2.13.0 # Ruby 2.5
 jdk:
-  - oraclejdk8
-  - oraclejdk7
-  - openjdk7
+  - openjdk9
+  - openjdk11
 before_install:
-  - gem install ruby-maven
-  - bundle install
+  - gem install bundler -v 1.17.3
 matrix:
   include:
     - rvm: jruby-head
-      jdk: oraclejdk8
+      jdk: openjdk10
   allow_failures:
-    - rvm: jruby-head
+    - rvm: jruby-head

data/CHANGELOG.md

@@ -1,6 +1,23 @@
 ## v0.6
 
-### v0.6.1 (pending)
+### v0.7.0
+
+* Drop support for JRuby 1.7. It probably still works, but we don't test against it anymore
+* Fix a thread safety issue with regards to adding requests to the parallel execution queue while the client is already processing a queue (#80)
+
+### v0.6.4
+
+* client_cert and client_key now take the literal keys as strings, OpenSSL::X509::Certificate/OpenSSL::PKey::Pkey instances, or key file paths. (#77)
+* Reduced unnecessary string copying (!78 - thanks @kares)
+
+### v0.6.2-v0.6.3
+
+* Fixed the use of authentication information in proxy URLs (#71)
+* Changed the default encoding to UTF-8 when a response MIME is application/json (#70)
+
+### v0.6.1
+
+* Manticore will accept a URI object (which it calls #to_s on) as an alternate to a String for the URL in client#get(url)
 
 ### v0.6.0
 

data/Gemfile

@@ -8,7 +8,9 @@ group :development, :test do
   gem "rspec", "~> 3.0"
   gem "rspec-its"
   gem "httpclient", "~> 2.3"
-  gem "rack", "~> 1.5"
+  gem "rack", ">= 2.1.4"
   gem "rake-compiler"
   gem "gserver"
-end
+  gem "simplecov"
+  gem "json"
+end

data/README.md

@@ -1,6 +1,8 @@
 # Manticore
 
-[![Build Status](https://travis-ci.org/cheald/manticore.png?branch=master)](https://travis-ci.org/cheald/manticore)
+**Note**: While I'll continue to maintain the library here, I've moved the canonical copy to Gitlab at https://gitlab.com/cheald/manticore - it is preferred that you submit issues and PRs there.
+
+[![Build Status](https://travis-ci.org/cheald/manticore.svg?branch=master)](https://travis-ci.org/cheald/manticore)
 
 Manticore is a fast, robust HTTP client built on the Apache HTTPClient libraries. It is only compatible with JRuby.
 

data/Rakefile

@@ -1,27 +1,27 @@
 require "bundler/gem_tasks"
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rspec_opts = ['--tty --color --format documentation']
+  spec.pattern = "spec/**/*_spec.rb"
+  spec.rspec_opts = ["--tty --color --format documentation"]
 end
 task :default => [:generate_certs, :spec]
 
 # Download and vendor the jars needed
-require 'jars/installer'
+require "jars/installer"
 task :install_jars do
   Jars::Installer.vendor_jars!
 end
 
 ## 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") }
+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/org/manticore"
-  ext.classpath = jars.map {|x| File.expand_path x}.join ':'
+  ext.classpath = jars.map { |x| File.expand_path x }.join ":"
 end
 
 # Generate all the stuff we need for a full test run
@@ -30,10 +30,10 @@ task :generate_certs do
   openssl = `which openssl`.strip
   keytool = `which keytool`.strip
 
-  Dir.glob("#{root}/*").each {|f| File.unlink f }
+  Dir.glob("#{root}/*").each { |f| File.unlink f }
 
-  # Create the CA
   cmds = [
+    # Create the CA
     "#{openssl} genrsa 4096 | #{openssl} pkcs8 -topk8 -nocrypt -out #{root}/root-ca.key",
     "#{openssl} req -sha256 -x509 -newkey rsa:4096 -nodes -key #{root}/root-ca.key -sha256 -days 365 -out #{root}/root-ca.crt -subj \"/C=US/ST=The Internet/L=The Internet/O=Manticore CA/OU=Manticore/CN=localhost\"",
 
@@ -41,15 +41,17 @@ task :generate_certs do
     "#{openssl} genrsa 4096 | #{openssl} pkcs8 -topk8 -nocrypt -out #{root}/client.key",
     "#{openssl} req -sha256 -key #{root}/client.key -newkey rsa:4096 -out #{root}/client.csr -subj \"/C=US/ST=The Internet/L=The Internet/O=Manticore Client/OU=Manticore/CN=localhost\"",
     "#{openssl} x509 -req -in #{root}/client.csr -CA #{root}/root-ca.crt -CAkey #{root}/root-ca.key -CAcreateserial -out #{root}/client.crt -sha256 -days 1",
+    "#{openssl} x509 -req -in #{root}/client.csr -CA #{root}/root-ca.crt -CAkey #{root}/root-ca.key -CAcreateserial -out #{root}/client-expired.crt -sha256 -days -7",
 
     # Create the server cert
     "#{openssl} genrsa 4096 | #{openssl} pkcs8 -topk8 -nocrypt -out #{root}/host.key",
     "#{openssl} req -sha256 -key #{root}/host.key -newkey rsa:4096 -out #{root}/host.csr -subj \"/C=US/ST=The Internet/L=The Internet/O=Manticore Host/OU=Manticore/CN=localhost\"",
     "#{openssl} x509 -req -in #{root}/host.csr -CA #{root}/root-ca.crt -CAkey #{root}/root-ca.key -CAcreateserial -out #{root}/host.crt -sha256 -days 1",
+    "#{openssl} x509 -req -in #{root}/host.csr -CA #{root}/root-ca.crt -CAkey #{root}/root-ca.key -CAcreateserial -out #{root}/host-expired.crt -sha256 -days -7",
 
     "#{keytool} -import -file #{root}/root-ca.crt -alias rootCA -keystore #{root}/truststore.jks -noprompt -storepass test123",
     "#{openssl} pkcs12 -export -clcerts -out #{root}/client.p12 -inkey #{root}/client.key -in #{root}/client.crt -certfile #{root}/root-ca.crt -password pass:test123",
   ]
 
-  cmds.each.with_index {|cmd, index| puts "#{index}. #{cmd}"; system cmd }
-end
+  cmds.each.with_index { |cmd, index| puts "#{index}. #{cmd}"; system cmd }
+end

data/ext/manticore/org/manticore/Manticore.java

@@ -39,8 +39,17 @@ public class Manticore implements Library {
     @JRubyMethod(name = "read_entity")
     public IRubyObject readEntity(ThreadContext context, IRubyObject rEntity, Block block) throws IOException {
       HttpEntity entity = (HttpEntity)rEntity.toJava(HttpEntity.class);
+
       String charset = EntityUtils.getContentCharSet(entity);
-      if(charset == null) { charset = HTTP.DEFAULT_CONTENT_CHARSET; }
+      if (charset == null) {
+        String mimeType = EntityUtils.getContentMimeType(entity);
+        if ( mimeType != null && mimeType.startsWith("application/json") ) {
+          charset = "UTF-8";
+        } else {
+          charset = HTTP.DEFAULT_CONTENT_CHARSET;
+        }
+      }
+
       Encoding encoding;
       try {
         encoding = context.getRuntime().getEncodingService().getEncodingFromString(charset);
@@ -57,7 +66,7 @@ public class Manticore implements Library {
 
     private IRubyObject readWholeEntity(ThreadContext context, HttpEntity entity, Encoding encoding) throws IOException {
       ByteList bl = new ByteList(EntityUtils.toByteArray(entity), false);
-      return RubyString.newStringShared(context.getRuntime(), bl, encoding);
+      return RubyString.newString(context.getRuntime(), bl, encoding);
     }
 
     private IRubyObject streamEntity(ThreadContext context, HttpEntity entity, Encoding encoding, Block block) throws IOException {
@@ -77,7 +86,7 @@ public class Manticore implements Library {
         byte[] tmp = new byte[4096];
         int l;
         while((l = instream.read(tmp)) != -1) {
-          block.call( context, RubyString.newString(context.getRuntime(), new ByteList(tmp, 0, l, true), encoding) );
+          block.call( context, RubyString.newStringShared(context.getRuntime(), new ByteList(tmp, 0, l, false), encoding) );
         }
       } finally {
         instream.close();
@@ -85,4 +94,4 @@ public class Manticore implements Library {
       return context.nil;
     }
   }
-}
+}

data/lib/faraday/adapter/manticore.rb

@@ -1,9 +1,9 @@
-require 'faraday'
+require "faraday"
 
 module Faraday
   class Adapter
     class Manticore < Faraday::Adapter
-      dependency { require 'manticore' }
+      dependency { require "manticore" }
 
       class ParallelManager
         def client=(client)
@@ -20,20 +20,15 @@ module Faraday
         ParallelManager.new
       end
 
-      def initialize(app, connection_options = {})
-        @connection_options = connection_options
-        super(app)
-      end
-
       def client(env)
         @client ||= begin
           opts = {}
           if ssl = env[:ssl].to_hash
             opts[:ssl] = {}
-            opts[:ssl][:verify]      = :disable if ssl[:verify] == false
-            opts[:ssl][:ca_file]     = ssl[:ca_file]
+            opts[:ssl][:verify] = ssl[:verify] unless ssl[:verify].nil?
+            opts[:ssl][:ca_file] = ssl[:ca_file]
             opts[:ssl][:client_cert] = ssl[:client_cert]
-            opts[:ssl][:client_key]  = ssl[:client_key]
+            opts[:ssl][:client_key] = ssl[:client_key]
           end
           conn_opts = @connection_options.dup
           if conn_opts.key?(:ssl)
@@ -50,7 +45,7 @@ module Faraday
         opts = {}
         if env.key? :request_headers
           opts[:headers] = env[:request_headers]
-          opts[:headers].reject! {|k, _| k.downcase == "content-length" }  # Manticore computes Content-Length
+          opts[:headers].reject! { |k, _| k.downcase == "content-length" }  # Manticore computes Content-Length
         end
         body = read_body(env)
         opts[:body] = body if body
@@ -60,9 +55,9 @@ module Faraday
           opts[:connect_timeout] = req[:open_timeout] if req.key?(:open_timeout)
           if prx = req[:proxy]
             opts[:proxy] = {
-              :url      => prx[:uri].to_s,
-              :user     => prx[:user],
-              :password => prx[:password]
+              :url => prx[:uri].to_s,
+              :user => prx[:user],
+              :password => prx[:password],
             }
           end
         end
@@ -106,6 +101,7 @@ module Faraday
         env[:body].respond_to?(:read) ? env[:body].read : env[:body]
       end
     end
+
     register_middleware nil, :manticore => :Manticore
   end
-end
+end

data/lib/manticore.rb

@@ -1,6 +1,6 @@
-require 'java'
-require 'uri'
-require 'cgi'
+require "java"
+require "uri"
+require "cgi"
 
 require_relative "./manticore_jars.rb"
 require_relative "./org/manticore/manticore-ext"
@@ -42,12 +42,12 @@ module Manticore
   class UnknownException < ManticoreException; end
 
   require_relative "./manticore/java_extensions"
-  require_relative './manticore/client/proxies'
-  require_relative './manticore/client'
-  require_relative './manticore/response'
-  require_relative './manticore/stubbed_response'
-  require_relative './manticore/cookie'
-  require_relative './manticore/facade'
+  require_relative "./manticore/client/proxies"
+  require_relative "./manticore/client"
+  require_relative "./manticore/response"
+  require_relative "./manticore/stubbed_response"
+  require_relative "./manticore/cookie"
+  require_relative "./manticore/facade"
 
   include Facade
   include_http_client
@@ -57,4 +57,4 @@ module Manticore
     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
+end

data/lib/manticore/client.rb

@@ -1,6 +1,7 @@
-require 'thread'
-require 'base64'
-require 'weakref'
+require "thread"
+require "base64"
+require "weakref"
+require "openssl_pkcs8_pure"
 
 module Manticore
   # @!macro [new] http_method_shared
@@ -13,9 +14,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 [Integer]  connect_timeout    Request-specific connect timeout
-  #   @option options [Integer]  socket_timeout     Request-specific socket timeout
-  #   @option options [Integer]  request_timeout    Request-specific request timeout
+  #   @option options [Float]    connect_timeout    Request-specific connect timeout (in seconds)
+  #   @option options [Float]    socket_timeout     Request-specific socket timeout (in seconds)
+  #   @option options [Float]    request_timeout    Request-specific request timeout (in seconds)
   #   @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
@@ -79,7 +80,7 @@ module Manticore
     include_package "org.apache.http.auth"
     include_package "java.util.concurrent"
     include_package "org.apache.http.client.protocol"
-    include_package 'org.apache.http.conn.ssl'
+    include_package "org.apache.http.conn.ssl"
     include_package "java.security.cert"
     include_package "java.security.spec"
     include_package "java.security"
@@ -105,14 +106,14 @@ module Manticore
     include ProxiesInterface
 
     # The default maximum pool size for requests
-    DEFAULT_MAX_POOL_SIZE   = 50
+    DEFAULT_MAX_POOL_SIZE = 50
 
     DEFAULT_REQUEST_TIMEOUT = 60
-    DEFAULT_SOCKET_TIMEOUT  = 10
+    DEFAULT_SOCKET_TIMEOUT = 10
     DEFAULT_CONNECT_TIMEOUT = 10
-    DEFAULT_MAX_REDIRECTS   = 5
+    DEFAULT_MAX_REDIRECTS = 5
     DEFAULT_EXPECT_CONTINUE = false
-    DEFAULT_STALE_CHECK     = false
+    DEFAULT_STALE_CHECK = false
 
     attr_reader :client
 
@@ -169,15 +170,15 @@ module Manticore
     # @option options [String]          ssl[:keystore_password]   (nil)        Password used for decrypting the client auth key store
     # @option options [String]          ssl[:keystore_type]       (nil)        Format of the key store, ie "JKS" or "PKCS12". If left nil, the type will be inferred from the keystore filename.
     # @option options [String]          ssl[:ca_file]             (nil)        OpenSSL-style path to an X.509 certificate to use to validate SSL certificates
-    # @option options [String]          ssl[:client_cert]         (nil)        OpenSSL-style path to an X.509 certificate to use for client authentication
-    # @option options [String]          ssl[:client_key]          (nil)        OpenSSL-style path to an RSA key to use for client authentication
+    # @option options [String|OpenSSL::X509::Certificate]   ssl[:client_cert]         (nil)        A string containing a base64-encoded X.509 certificate, OR a path to an OpenSSL-style X.509 certificate, OR an instance of OpenSSL::X509::Certificate
+    # @option options [String|OpenSSL::PKey::Pkey]          ssl[:client_key]          (nil)        A string containing a base64-encoded RSA key to use for client authentication, OR a path to an OpenSSL-style RSA key, OR an instance of OpenSSL::PKey::PKey
     # @option options [boolean]         ssl[:track_state]         (false)      Turn on or off connection state tracking. This helps prevent SSL information from leaking across threads, but means that connections
     #                                                                             can't be shared across those threads. This should generally be left off unless you know what you're doing.
     def initialize(options = {})
       @finalizers = []
       self.class.shutdown_on_finalize self, @finalizers
 
-      builder  = client_builder
+      builder = client_builder
       builder.set_user_agent options.fetch(:user_agent, "Manticore #{VERSION}")
       @options = options
       @use_cookies = options.fetch(:cookies, false)
@@ -195,24 +196,24 @@ module Manticore
 
       @keepalive = options.fetch(:keepalive, true)
       if @keepalive == false
-        builder.set_connection_reuse_strategy {|response, context| 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.set_so_timeout( options.fetch(:socket_timeout, DEFAULT_SOCKET_TIMEOUT) * 1000 )
-      socket_config_builder.set_tcp_no_delay( options.fetch(:tcp_no_delay, true) )
+      socket_config_builder.set_so_timeout(options.fetch(:socket_timeout, DEFAULT_SOCKET_TIMEOUT) * 1000)
+      socket_config_builder.set_tcp_no_delay(options.fetch(:tcp_no_delay, true))
       builder.set_default_socket_config socket_config_builder.build
 
       builder.set_connection_manager pool(options)
 
       request_config = RequestConfig.custom
-      request_config.set_connection_request_timeout     options.fetch(:request_timeout, DEFAULT_REQUEST_TIMEOUT) * 1000
-      request_config.set_connect_timeout                options.fetch(:connect_timeout, DEFAULT_CONNECT_TIMEOUT) * 1000
-      request_config.set_socket_timeout                 options.fetch(:socket_timeout, DEFAULT_SOCKET_TIMEOUT) * 1000
-      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_connection_request_timeout options.fetch(:request_timeout, DEFAULT_REQUEST_TIMEOUT) * 1000
+      request_config.set_connect_timeout options.fetch(:connect_timeout, DEFAULT_CONNECT_TIMEOUT) * 1000
+      request_config.set_socket_timeout options.fetch(:socket_timeout, DEFAULT_SOCKET_TIMEOUT) * 1000
+      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_circular_redirects_allowed false
 
@@ -222,7 +223,7 @@ module Manticore
       @client = builder.build
       finalize @client, :close
       @options = options
-      @async_requests = []
+      @async_requests = Queue.new
       @stubs = {}
     end
 
@@ -233,7 +234,7 @@ module Manticore
         max: stats.get_max,
         leased: stats.get_leased,
         pending: stats.get_pending,
-        available: stats.get_available
+        available: stats.get_available,
       }
     end
 
@@ -333,8 +334,9 @@ module Manticore
     # @return [Array] An array of the responses from the requests executed.
     def execute!
       method = executor.java_method(:submit, [java.util.concurrent.Callable.java_class])
-      result = @async_requests.map {|r| method.call r }
-      @async_requests.clear
+
+      result = []
+      result << method.call(@async_requests.pop) until @async_requests.empty?
       result.map do |future|
         begin
           future.get
@@ -357,8 +359,8 @@ module Manticore
 
     def self.shutdown_on_finalize(client, objs)
       ObjectSpace.define_finalizer client, -> {
-        objs.each {|obj, args| obj.send(*args) rescue nil }
-      }
+                                     objs.each { |obj, args| obj.send(*args) rescue nil }
+                                   }
     end
 
     protected
@@ -383,13 +385,15 @@ module Manticore
     end
 
     def pool_builder(options)
-      http_sf  = PlainConnectionSocketFactory.new
+      http_sf = PlainConnectionSocketFactory.new
 
+      # :nocov:
       if options[:ignore_ssl_validation]
-        $stderr.puts 'The options[:ignore_ssl_validation] setting is deprecated in favor of options[:ssl][:verify]'
+        $stderr.puts "The options[:ignore_ssl_validation] setting is deprecated in favor of options[:ssl][:verify]"
         options[:ssl] ||= {}
-        options[:ssl]   = {:verify => !options.delete(:ignore_ssl_validation)}.merge(options[:ssl])
+        options[:ssl] = {:verify => !options.delete(:ignore_ssl_validation)}.merge(options[:ssl])
       end
+      # :nocov:
 
       https_sf = ssl_socket_factory_from_options options.fetch(:ssl, {})
       registry = RegistryBuilder.create.register("http", http_sf).register("https", https_sf).build
@@ -416,10 +420,10 @@ module Manticore
 
     def request(klass, url, options, &block)
       req, context = request_from_options(klass, url, options)
-      async        = options.delete(:async)
-      background   = options.delete(:async_background)
+      async = options.delete(:async)
+      background = options.delete(:async_background)
       create_executor_if_needed if (background || async)
-      response     = response_object_for(req, context, &block)
+      response = response_object_for(req, context, &block)
 
       if async
         @async_requests << response
@@ -439,13 +443,14 @@ module Manticore
 
       match_key = @stubs.keys.find { |k| request_uri.match(k) }
       if match_key
-        StubbedResponse.new(self, request, context, &block).stub( @stubs[match_key] )
+        StubbedResponse.new(self, request, context, &block).stub(@stubs[match_key])
       else
         Response.new(self, request, context, &block)
       end
     end
 
     def uri_from_url_and_options(url, options)
+      url = url.to_s if url.is_a?(URI)
       builder = URIBuilder.new(url)
       pairs = struct_to_name_value_pairs(options[:query])
       builder.add_parameters pairs unless pairs.empty?
@@ -455,7 +460,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.kind_of?(HttpEntityEnclosingRequestBase)
+      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
@@ -478,23 +483,30 @@ module Manticore
         if req_options[:proxy]
           config.set_proxy get_proxy_host(req_options[:proxy])
         end
-        config.set_max_redirects req_options[:max_redirects]                       if req_options[:max_redirects]
-        config.set_redirects_enabled !!req_options[:follow_redirects]              if req_options.fetch(:follow_redirects, nil) != nil
-        config.set_connect_timeout req_options[:connect_timeout] * 1000            if req_options[:connect_timeout]
-        config.set_socket_timeout req_options[:socket_timeout] * 1000              if req_options[:socket_timeout]
+        config.set_max_redirects req_options[:max_redirects] if req_options[:max_redirects]
+        config.set_redirects_enabled !!req_options[:follow_redirects] if req_options.fetch(:follow_redirects, nil) != nil
+        config.set_connect_timeout req_options[:connect_timeout] * 1000 if req_options[:connect_timeout]
+        config.set_socket_timeout req_options[:socket_timeout] * 1000 if req_options[:socket_timeout]
         config.set_connection_request_timeout req_options[:request_timeout] * 1000 if req_options[:request_timeout]
         req.set_config config.build
       end
 
-
-      options[:headers].each {|k, v| req[k] = v } if options.key?(:headers)
-
+      headers = []
       # Support keepalive on HTTP/1.0 connections
-      req["Connection"] = "Keep-Alive" if @keepalive
+      headers.push BasicHeader.new("Connection", "Keep-Alive") if @keepalive
+
+      if options.key?(:headers)
+        options[:headers].each do |k, v|
+          Array(v).each do |_v|
+            headers.push BasicHeader.new(k, _v)
+          end
+        end
+      end
+      req.set_headers headers.to_java(BasicHeader) unless headers.empty?
 
       context = HttpClientContext.new
       proxy_user = req_options[:proxy].is_a?(Hash) && (req_options[:proxy][:user] || req_options[:proxy][:username])
-      auth_from_options(req, req_options, context) if req_options.key?(:auth) || proxy_user
+      auth_from_options(req, req_options, context)
 
       if @use_cookies == :per_request
         store = BasicCookieStore.new
@@ -529,7 +541,16 @@ module Manticore
 
     def auth_from_options(req, options, context)
       proxy = options.fetch(:proxy, {})
-      if options[:auth] || proxy[:user] || proxy[:username]
+
+      proxy_user, proxy_pass = if proxy.is_a?(String)
+                                 proxy_uri = URI.parse(proxy)
+                                 [proxy_uri.user, proxy_uri.password]
+                               else
+                                 [(proxy[:user] || proxy[:username]),
+                                  (proxy[:pass] || proxy[:password])]
+                               end
+
+      if options[:auth] || proxy_user
         provider = BasicCredentialsProvider.new
         if options[:auth]
           username = options[:auth][:user] || options[:auth][:username]
@@ -547,10 +568,8 @@ module Manticore
           end
         end
 
-        if proxy[:user] || proxy[:username]
-          username = proxy[:user] || proxy[:username]
-          password = proxy[:pass] || proxy[:password]
-          provider.set_credentials AuthScope.new(get_proxy_host(proxy)), UsernamePasswordCredentials.new(username, password)
+        if proxy_user
+          provider.set_credentials AuthScope.new(get_proxy_host(proxy)), UsernamePasswordCredentials.new(proxy_user, proxy_pass)
         end
         context.set_credentials_provider(provider)
       end
@@ -561,9 +580,9 @@ module Manticore
       when nil
         []
       when Hash
-        value.flat_map {|key, val| struct_to_name_value_pairs val, namespace ? "#{namespace}[#{key}]" : key }
+        value.flat_map { |key, val| struct_to_name_value_pairs val, namespace ? "#{namespace}[#{key}]" : key }
       when Array
-        value.flat_map {|val| struct_to_name_value_pairs val, namespace }
+        value.flat_map { |val| struct_to_name_value_pairs val, namespace }
       else
         BasicNameValuePair.new(namespace, value.to_s)
       end
@@ -572,6 +591,7 @@ module Manticore
     # Apache HTTP assumes ISO_8859_1 for StringEntities; we'll try to be nice and pass that when possible
     # so that it doesn't have to any multibyte work.
     ISO_8859_1 = "ISO-8859-1".freeze
+
     def minimum_encoding_for(string)
       if string.ascii_only?
         ISO_8859_1
@@ -623,44 +643,50 @@ module Manticore
     end
 
     KEY_EXTRACTION_REGEXP = /(?:^-----BEGIN(.* )PRIVATE KEY-----\n)(.*?)(?:-----END\1PRIVATE KEY.*$)/m
+
     def setup_key_store(ssl_options, context)
       key_store = get_store(:keystore, ssl_options) if ssl_options.key?(:keystore)
       keystore_password = (ssl_options[:keystore_password] || "").to_java.toCharArray
 
       # Support OpenSSL-style bare X.509 certs with an RSA key
-      # This is really dumb - we have to b64-decode the key ourselves, and we can only support PKCS8
       if ssl_options[:client_cert] && ssl_options[:client_key]
         key_store ||= blank_keystore
         certs, key = nil, nil
-        open(ssl_options[:client_cert]) do |fp|
-          certs = CertificateFactory.get_instance("X509").generate_certificates(fp.to_inputstream).to_array([].to_java(Certificate))
-        end
+
+        cert_str = if ssl_options[:client_cert].is_a?(OpenSSL::X509::Certificate)
+                     ssl_options[:client_cert].to_s
+                   elsif ssl_options[:client_cert].is_a?(String) && File.exists?(ssl_options[:client_cert])
+                     File.read(ssl_options[:client_cert])
+                   else
+                     ssl_options[:client_cert].to_s
+                   end
+
+        cert_stream = java.io.ByteArrayInputStream.new(cert_str.strip.to_java_bytes)
+        certs = CertificateFactory.get_instance("X509").generate_certificates(cert_stream).to_array([].to_java(Certificate))
+
+        key_str = if ssl_options[:client_key].is_a?(OpenSSL::PKey::PKey)
+                    ssl_options[:client_key].to_pem_pkcs8
+                  elsif ssl_options[:client_key].is_a?(String) && File.exists?(ssl_options[:client_key])
+                    File.read(ssl_options[:client_key])
+                  else
+                    ssl_options[:client_key].to_s
+                  end
 
         # Add each of the keys in the given keyfile into the keystore.
-        open(ssl_options[:client_key]) do |fp|
-          key_parts = fp.read.scan(KEY_EXTRACTION_REGEXP)
-          key_parts.each do |type, b64key|
-            body = Base64.decode64 b64key
-            spec = PKCS8EncodedKeySpec.new(body.to_java_bytes)
-            type = type.strip
-            type = "RSA" if type == ""
-            key = KeyFactory.getInstance(type).generatePrivate(spec)
-            key_store.set_key_entry("key-#{Digest::SHA1.hexdigest(body)}", key, keystore_password, certs)
-          end
+        key_parts = key_str.scan(KEY_EXTRACTION_REGEXP)
+        key_parts.each do |type, b64key|
+          body = Base64.decode64 b64key
+          spec = PKCS8EncodedKeySpec.new(body.strip.to_java_bytes)
+          type = type.strip
+          type = "RSA" if type == ""
+          key = KeyFactory.getInstance(type).generatePrivate(spec)
+          key_store.set_key_entry("key-#{Digest::SHA1.hexdigest(body)}", key, keystore_password, certs)
         end
       end
 
       context.load_key_material(key_store, keystore_password) if key_store
     end
 
-    def get_trust_store(options)
-      get_store :truststore, options
-    end
-
-    def get_key_store(options)
-      get_store :keystore, options
-    end
-
     def get_store(prefix, options)
       KeyStore.get_instance(options[:"#{prefix}_type"] || guess_store_type(options[prefix])).tap do |store|
         instream = open(options[prefix], "rb").to_inputstream
@@ -669,7 +695,7 @@ module Manticore
     end
 
     def blank_keystore
-      KeyStore.get_instance(KeyStore.get_default_type).tap {|k| k.load(nil, nil) }
+      KeyStore.get_instance(KeyStore.get_default_type).tap { |k| k.load(nil, nil) }
     end
 
     def guess_store_type(filename)
@@ -682,7 +708,7 @@ module Manticore
 
     def treat_params_as_query(options)
       if options.key?(:params) && !options.key?(:query)
-        options.dup.tap {|o| o[:query] = o.delete(:params) }
+        options.dup.tap { |o| o[:query] = o.delete(:params) }
       else
         options
       end