Method: Manticore::Client#initialize

Defined in:: lib/manticore/client.rb

#initialize(options = {}) {|builder, request_config| ... } ⇒ `Client`

Create a new HTTP client with a backing request pool. if you pass a block to the initializer, the underlying HttpClientBuilder and RequestConfig.Builder will be yielded so that you can operate on them directly.

Examples:

Simple instantiation and usage

client = Manticore::Client.new
client.get("http://www.google.com")

Instantiation with a block

client = Manticore::Client.new(socket_timeout: 5) do |http_client_builder, request_builder|
  http_client_builder.disable_redirect_handling
end

Parameters:

options (Hash) (defaults to: {}) —

Client pool options

Options Hash (options):

user_agent (String) —

The user agent used in requests.
pool_max (Integer) — default: 50 —

The maximum number of active connections in the pool
pool_max_per_route (integer) — default: pool_max —

Sets the maximum number of active connections for a given target endpoint
cookies (boolean) — default: true —

enable or disable automatic cookie management between requests
compression (boolean) — default: true —

enable or disable transparent gzip/deflate support
request_timeout (integer) — default: 60 —

Sets the timeout for requests. Raises Timeout on failure.
connect_timeout (integer) — default: 10 —

Sets the timeout for connections. Raises Manticore::Timeout on failure.
socket_timeout (integer) — default: 10 —

Sets SO_TIMEOUT for open connections. A value of 0 is an infinite timeout. Raises Manticore::Timeout on failure.
tcp_no_delay (boolean) — default: true —

Enable or disable Nagle’s algorithm
request_timeout (integer) — default: 60 —

Sets the timeout for a given request. Raises Manticore::Timeout on failure.
max_redirects (integer) — default: 5 —

Sets the maximum number of redirects to follow.
automatic_retries (integer) — default: 3 —

Sets the number of times the client will automatically retry failed requests.
retry_non_idempotent (boolean) — default: 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
expect_continue (boolean) — default: false —

Enable support for HTTP 100
stale_check (boolean) — default: false —

Enable support for stale connection checking. Adds overhead.
check_connection_timeout (integer) — default: 2_000 —

Connections that haven’t been used in this many milliseconds will be validated before being used. Set to a negative number to disable.
proxy (String) —

Proxy host in form: proxy.org:1234
proxy (Hash) —

Proxy host in form: ‘proxy.org’[, port: 80[, scheme: ‘http’[, user: ‘username@host’, password: ‘password’]]]
proxy (Hash) —

Proxy host in form: ‘proxy.org:1234’[, user: ‘username@host’, password: ‘password’]]]
proxy (URI) —

Proxy host as a URI object
keepalive (Boolean) — default: true —

Whether to allow connections to be reused. Defaults to true.
ssl (Hash) —

Hash of options for configuring SSL
ssl[:protocols] (Array<String>) — default: nil —

A list of protocols that Manticore should accept
ssl[:cipher_suites] (Array<String>) — default: nil —

A list of cipher suites that Manticore should accept
ssl[:verify] (Symbol) — default: :default —

Hostname verification setting. Set to ‘:none` to turn off hostname verification. Setting to `:browser` will cause Manticore to accept a certificate for *.foo.com for all subdomains and sub-subdomains (eg a.b.foo.com). The default `:default` is like `:browser` but more strict - only accepts a single level of subdomains for wildcards, eg `b.foo.com` will be accepted for a `*.foo.com` certificate, but `a.b.foo.com` will not be.
ssl[:trust_strategy] (Client::TrustStrategiesInterface) — default: nil —

A trust strategy to use in addition to any built by ‘ssl`. @see Client::TrustStrategiesInterface#coerce
ssl[:truststore] (String) — default: nil —

Path to a custom trust store to use the verifying SSL connections
ssl[:truststore_password] (String) — default: nil —

Password used for decrypting the server trust store
ssl[:truststore_type] (String) — default: nil —

Format of the trust store, ie “JKS” or “PKCS12”. If left nil, the type will be inferred from the truststore filename.
ssl[:keystore] (String) — default: nil —

Path to a custom key store to use for client certificate authentication
ssl[:keystore_password] (String) — default: nil —

Password used for decrypting the client auth key store
ssl[:keystore_type] (String) — default: nil —

Format of the key store, ie “JKS” or “PKCS12”. If left nil, the type will be inferred from the keystore filename.
ssl[:ca_file] (String) — default: nil —

OpenSSL-style path to an X.509 certificate to use to validate SSL certificates
ssl[:client_cert] (String|OpenSSL::X509::Certificate) — default: 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
ssl[:client_key] (String|OpenSSL::PKey::Pkey) — default: 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
ssl[:track_state] (boolean) — default: 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.

Yields:

(builder, request_config)

See Also:

# File 'lib/manticore/client.rb', line 199

def initialize(options = {})
  @finalizer = Finalizer.new
  self.class.shutdown_on_finalize self, @finalizer

  builder = client_builder
  builder.set_user_agent options.fetch(:user_agent, "Manticore #{VERSION}")
  @options = options
  @use_cookies = options.fetch(:cookies, false)
  builder.disable_cookie_management unless @use_cookies
  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 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
  # Since we're running this for JRuby which does not have context separation within the JVM
  # We can disable this for connection reuse.
  builder.disable_connection_state unless options.fetch(:ssl, {}).fetch(:track_state, false)

  @keepalive = options.fetch(:keepalive, true)
  if @keepalive == false
    builder.set_connection_reuse_strategy NoConnectionReuseStrategy::INSTANCE # return false
  else
    builder.set_connection_reuse_strategy DefaultConnectionReuseStrategy.new
  end

  builder.set_default_socket_config socket_config_from_options(options)
  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_stale_connection_check_enabled options.fetch(:stale_check, DEFAULT_STALE_CHECK)
  request_config.set_circular_redirects_allowed false

  yield builder, request_config if block_given?

  builder.set_default_request_config request_config.build
  @client = builder.build
  finalize @client, :close
  @options = options
  @async_requests = Queue.new
  @stubs = {}
end

Method: Manticore::Client#initialize

#initialize(options = {}) {|builder, request_config| ... } ⇒ Client

#initialize(options = {}) {|builder, request_config| ... } ⇒ `Client`