ClientBuilder

A builder of Finagle Clients.

Please see the Finagle user guide for information on a newer set of client-construction APIs introduced in Finagle v6.

val client = ClientBuilder()
  .codec(Http)
  .hosts("localhost:10000,localhost:10001,localhost:10003")
  .hostConnectionLimit(1)
  .tcpConnectTimeout(1.second)        // max time to spend establishing a TCP connection.
  .retries(2)                         // (1) per-request retries
  .reportTo(new OstrichStatsReceiver) // export host-level load data to ostrich
  .logger(Logger.getLogger("http"))
  .build()

The ClientBuilder requires the definition of cluster, codec, and hostConnectionLimit. In Scala, these are statically type checked, and in Java the lack of any of the above causes a runtime error.

The build method uses an implicit argument to statically typecheck the builder (to ensure completeness, see above). The Java compiler cannot provide such implicit, so we provide a separate function in Java to accomplish this. Thus, the Java code for the above is

Service<HttpRequest, HttpResponse> service =
 ClientBuilder.safeBuild(
   ClientBuilder.get()
     .codec(new Http())
     .hosts("localhost:10000,localhost:10001,localhost:10003")
     .hostConnectionLimit(1)
     .tcpConnectTimeout(1.second)
     .retries(2)
     .reportTo(new OstrichStatsReceiver())
     .logger(Logger.getLogger("http")))

Alternatively, using the unsafeBuild method on ClientBuilder verifies the builder dynamically, resulting in a runtime error instead of a compiler error.

Defaults

The following defaults are applied to clients constructed via ClientBuilder, unless overridden with the corresponding method. These defaults were chosen carefully so as to work well for most use cases.

Commonly-configured options:

connectTimeout: Duration.Top
tcpConnectTimeout: 1 second
requestTimeout: Duration.Top
timeout: Duration.Top
hostConnectionLimit: Int.MaxValue
hostConnectionCoresize: 0
hostConnectionIdleTime: Duration.Top
hostConnectionMaxWaiters: Int.MaxValue
failFast: true
failureAccrualParams, failureAccrualFactory: numFailures = 5, markDeadFor = 5 seconds

Advanced options:

Before changing any of these, make sure that you know exactly how they will affect your application -- these options are typically only changed by expert users.

keepAlive: Unspecified, in which case the Java default of false is used
readerIdleTimeout: Duration.Top
writerIdleTimeout: Duration.Top
hostConnectionMaxIdleTime: Duration.Top
hostConnectionMaxLifeTime: Duration.Top
sendBufferSize, recvBufferSize: OS-defined default value

Linear Supertypes

AnyRef, Any

Type Members

type FullySpecifiedConfig = ClientConfig[Req, Rep, Yes, Yes, Yes]
type This = ClientBuilder[Req, Rep, HasCluster, HasCodec, HasHostConnectionLimit]
type ThisConfig = ClientConfig[Req, Rep, HasCluster, HasCodec, HasHostConnectionLimit]

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def baseDtab(baseDtab: () ⇒ Dtab): This

The base com.twitter.finagle.Dtab used to interpret logical destinations for this client.
The base com.twitter.finagle.Dtab used to interpret logical destinations for this client. (This is given as a function to permit late initialization of com.twitter.finagle.Dtab.base.)
def build()(implicit THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ClientBuilder_DOCUMENTATION: ClientConfigEvidence[HasCluster, HasCodec, HasHostConnectionLimit]): Service[Req, Rep]

Construct a Service.
def buildFactory()(implicit THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ClientBuilder_DOCUMENTATION: ClientConfigEvidence[HasCluster, HasCodec, HasHostConnectionLimit]): ServiceFactory[Req, Rep]

Construct a ServiceFactory.
Construct a ServiceFactory. This is useful for stateful protocols (e.g., those that support transactions or authentication).
def channelFactory(cf: ChannelFactory): This

Use the given channel factory instead of the default.
Use the given channel factory instead of the default. Note that when using a non-default ChannelFactory, finagle can't meaningfully reference count factory usage, and so the caller is responsible for calling releaseExternalResources().
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cluster(cluster: Cluster[SocketAddress]): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

Specify a cluster directly.
Specify a cluster directly. A com.twitter.finagle.builder.Cluster defines a dynamic mechanism for specifying a set of endpoints to which this client remains connected.
def codec[Req1, Rep1](codecFactory: (ClientCodecConfig) ⇒ Codec[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, HasHostConnectionLimit]

A variation of codec for codecs that support only client-codecs.
def codec[Req1, Rep1](codecFactory: CodecFactory[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, HasHostConnectionLimit]

A variation of codec that supports codec factories.
A variation of codec that supports codec factories. This is used by codecs that need dynamic construction, but should be transparent to the user.
def codec[Req1, Rep1](codec: Codec[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, HasHostConnectionLimit]

Specify the codec.
Specify the codec. The codec implements the network protocol used by the client, and consequently determines the Req and Rep type variables. One of the codec variations is required.
def connectTimeout(duration: Duration): This

The connect timeout is the timeout applied to the acquisition of a Service.
The connect timeout is the timeout applied to the acquisition of a Service. This includes both queueing time (eg. because we cannot create more connections due to hostConnectionLimit and there are more than hostConnectionLimit requests outstanding) as well as physical connection time. Futures returned from factory() will always be satisfied within this timeout.
This timeout is also used for name resolution, separately from queueing and physical connection time, so in the worst case the time to acquire a service may be double the given duration before timing out.
def daemon(daemonize: Boolean): This

When true, the client is daemonized.
When true, the client is daemonized. As with java threads, a process can exit only when all remaining clients are daemonized. False by default.
def dest(name: Name): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

The logical destination of requests dispatched through this client.
def dest(addr: String): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

The logical destination of requests dispatched through this client, as evaluated by a resolver.
The logical destination of requests dispatched through this client, as evaluated by a resolver. If the name evaluates a label, this replaces the builder's current name.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exceptionCategorizer(exceptionStatsHandler: ExceptionStatsHandler): This

Provide an alternative to putting all request exceptions under a "failures" stat.
Provide an alternative to putting all request exceptions under a "failures" stat. Typical implementations may report any cancellations or validation errors separately so success rate considers only valid non cancelled requests.
exceptionStatsHandler
function to record failure details.
def expHostConnectionBufferSize(size: Int): This

Experimental option to buffer size connections from the pool.
Experimental option to buffer size connections from the pool. The buffer is fast and lock-free, reducing contention for services with very high requests rates. The buffer size should be sized roughly to the expected concurrency. Buffers sized by power-of-twos may be faster due to the use of modular arithmetic.

Note
This will be integrated into the mainline pool, at which time the experimental option will go away.
def failFast(enabled: Boolean): This

Marks a host dead on connection failure.
Marks a host dead on connection failure. The host remains dead until we successfully connect. Intermediate connection attempts *are* respected, but host availability is turned off during the reconnection period.
def failureAccrualFactory(factory: (Timer) ⇒ ServiceFactoryWrapper): This

Completely replaces the FailureAccrualFactory from the underlying stack with the ServiceFactoryWrapper returned from the given function factory.
Completely replaces the FailureAccrualFactory from the underlying stack with the ServiceFactoryWrapper returned from the given function factory.
To completely disable FailureAccrualFactory use noFailureAccrual.
def failureAccrualParams(pair: (Int, Duration)): This

Use the given parameters for failure accrual.
Use the given parameters for failure accrual. The first parameter is the number of *successive* failures that are required to mark a host failed. The second parameter specifies how long the host is dead for, once marked.
To completely disable FailureAccrualFactory use noFailureAccrual.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def group(group: Group[SocketAddress]): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]
def hashCode(): Int

Definition Classes
AnyRef → Any
def hostConnectionCoresize(value: Int): This

The core size of the connection pool: the pool is not shrinked below this limit.
def hostConnectionIdleTime(timeout: Duration): This

The amount of time a connection is allowed to linger (when it otherwise would have been closed by the pool) before being closed.
def hostConnectionLimit(value: Int): ClientBuilder[Req, Rep, HasCluster, HasCodec, Yes]

The maximum number of connections that are allowed per host.
The maximum number of connections that are allowed per host. Required. Finagle guarantees to never have more active connections than this limit.
def hostConnectionMaxIdleTime(timeout: Duration): This

The maximum time a connection is allowed to linger unused.
def hostConnectionMaxLifeTime(timeout: Duration): This

The maximum time a connection is allowed to exist, regardless of occupancy.
def hostConnectionMaxWaiters(nWaiters: Int): This

The maximum queue size for the connection pool.
def hosts(address: SocketAddress): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

A convenience method for specifying a one-host java.net.SocketAddress client.
def hosts(addrs: Seq[SocketAddress]): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

A variant of {{hosts}} that takes a sequence of java.net.SocketAddress instead.
def hosts(hostnamePortCombinations: String): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

Specify the set of hosts to connect this client to.
Specify the set of hosts to connect this client to. Requests will be load balanced across these. This is a shorthand form for specifying a cluster.
One of the {{hosts}} variations or direct specification of the cluster (via {{cluster}}) is required.
hostnamePortCombinations
comma-separated "host:port" string.
def httpProxy(httpProxy: SocketAddress): This

Make connections via the given HTTP proxy.
Make connections via the given HTTP proxy. If this is defined concurrently with socksProxy, the order in which they are applied is undefined.
def httpProxyUsernameAndPassword(credentials: Credentials): This

For the http proxy use these Credentials for authentication.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def keepAlive(value: Boolean): This

Apply TCP keepAlive (SO_KEEPALIVE socket option).
def loadBalancer(loadBalancer: LoadBalancerFactory): This

Specify a load balancer.
Specify a load balancer. The load balancer implements a strategy for choosing one from a set of hosts to service a request
def logger(logger: Logger): This

Log very detailed debug information to the given logger.
def monitor(mFactory: (String) ⇒ Monitor): This
def name(value: String): This

Give a meaningful name to the client.
Give a meaningful name to the client. Required.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def noFailureAccrual: This

Disables FailureAccrualFactory.
Disables FailureAccrualFactory.
To replace the FailureAccrualFactory use failureAccrualFactory.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def params: Params
def readerIdleTimeout(duration: Duration): This

The maximum time a connection may have received no data.
def recvBufferSize(value: Int): This

Sets the TCP recv buffer size.
def reportHostStats(receiver: StatsReceiver): This

Report per host stats to the given StatsReceiver.
Report per host stats to the given StatsReceiver. The statsReceiver will be scoped per client, like this: client/connect_latency_ms_max/0.0.0.0:64754
def reportTo(receiver: StatsReceiver): This

Report stats to the given StatsReceiver.
Report stats to the given StatsReceiver. This will report verbose global statistics and counters, that in turn may be exported to monitoring applications.

Note
Per hosts statistics will NOT be exported to this receiver
See also
ClientBuilder.reportHostStats
def requestTimeout(duration: Duration): This

The request timeout is the time given to a *single* request (if there are retries, they each get a fresh request timeout).
The request timeout is the time given to a *single* request (if there are retries, they each get a fresh request timeout). The timeout is applied only after a connection has been acquired. That is: it is applied to the interval between the dispatch of the request and the receipt of the response.
def responseClassifier: ResponseClassifier

The currently configured com.twitter.finagle.service.ResponseClassifier.
The currently configured com.twitter.finagle.service.ResponseClassifier.

Note
If unspecified, the default classifier is com.twitter.finagle.service.ResponseClassifier.Default.
def responseClassifier(classifier: ResponseClassifier): This

Configure a com.twitter.finagle.service.ResponseClassifier which is used to determine the result of a request/response.
Configure a com.twitter.finagle.service.ResponseClassifier which is used to determine the result of a request/response.
This allows developers to give Finagle the additional application-specific knowledge necessary in order to properly classify them. Without this, Finagle cannot make judgements about application level failures as it only has a narrow understanding of failures (for example: transport level, timeouts, and nacks).
As an example take an HTTP client that receives a response with a 500 status code back from a server. To Finagle this is a successful request/response based solely on the transport level. The application developer may want to treat all 500 status codes as failures and can do so via a com.twitter.finagle.service.ResponseClassifier.
It is a PartialFunction and as such multiple classifiers can be composed together via PartialFunction.orElse.

Note
If unspecified, the default classifier is com.twitter.finagle.service.ResponseClassifier.Default which is a total function fully covering the input domain.
See also
com.twitter.finagle.http.service.HttpResponseClassifier for some HTTP classification tools.
def retries(value: Int): This

Retry (some) failed requests up to value - 1 times.
Retry (some) failed requests up to value - 1 times.
Retries are only done if the request failed with something known to be safe to retry. This includes WriteExceptions and Failures that are marked restartable.
The configured policy has jittered backoffs between retries.
value
the maximum number of attempts (including retries) that can be made.
- A value of 1 means one attempt and no retries on failure.
- A value of 2 means one attempt and then a single retry if the failure is known to be safe to retry.
Note
The failures seen in the client will not include application level failures. This is particularly important for codecs that include exceptions, such as Thrift. This is only applicable to service-builds (build()).
See also
retryBudget for governing how many failed requests are eligible for retries.
com.twitter.finagle.service.RetryPolicy.tries
def retryBudget(budget: RetryBudget, backoffSchedule: Stream[Duration]): This

The budget is shared across requests and governs the number of retries that can be made.
The budget is shared across requests and governs the number of retries that can be made. When used for requeues, includes a stream of delays used to delay each retry.
Helps prevent clients from overwhelming the downstream service.

See also
retryPolicy for per-request rules on which failures are eligible for retries.
def retryBudget(budget: RetryBudget): This

The budget is shared across requests and governs the number of retries that can be made.
The budget is shared across requests and governs the number of retries that can be made.
Helps prevent clients from overwhelming the downstream service.

See also
retryPolicy for per-request rules on which failures are eligible for retries.
def retryPolicy(value: RetryPolicy[Try[Nothing]]): This

Retry failed requests according to the given RetryPolicy.
Retry failed requests according to the given RetryPolicy.

Note
The failures seen in the client will not include application level failures. This is particularly important for codecs that include exceptions, such as Thrift. This is only applicable to service-builds (build()).
See also
retryBudget for governing how many failed requests are eligible for retries.
def sendBufferSize(value: Int): This

Sets the TCP send buffer size.
def socksProxy(socksProxy: Option[SocketAddress]): This

Make connections via the given SOCKS proxy.
Make connections via the given SOCKS proxy. If this is defined concurrently with httpProxy, the order in which they are applied is undefined.
def socksUsernameAndPassword(credentials: (String, String)): This

For the socks proxy use this username for authentication.
For the socks proxy use this username for authentication. socksPassword and socksProxy must be set as well
def stack[Req1, Rep1](client: StackBasedClient[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, Yes]

Overrides the stack and com.twitter.finagle.Client that will be used by this builder.
Overrides the stack and com.twitter.finagle.Client that will be used by this builder.
client
A StackBasedClient representation of a com.twitter.finagle.Client. client is materialized with the state of configuration when build is called. There is no guarantee that all builder parameters will be used by the resultant Client; it is up to the discretion of client itself and the protocol implementation. For example, the Mux protocol has no use for most connection pool parameters (e.g. hostConnectionLimit). Thus when configuring com.twitter.finagle.ThriftMux clients (via stack(ThriftMux.client)), such connection pool parameters will not be applied.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tcpConnectTimeout(duration: Duration): This

Specify the TCP connection timeout.
def timeout(duration: Duration): This

Total request timeout.
Total request timeout. This timeout is applied from the issuance of a request (through service(request)) until the satisfaction of that reply future. No request will take longer than this.
Applicable only to service-builds (build())
def tls(sslContext: SSLContext, hostname: Option[String]): This

Encrypt the connection with SSL.
Encrypt the connection with SSL. The Engine to use can be passed into the client. This allows the user to use client certificates SSL Hostname Validation is performed, on the passed in hostname
def tls(sslContext: SSLContext): This

Encrypt the connection with SSL.
Encrypt the connection with SSL. The Engine to use can be passed into the client. This allows the user to use client certificates No SSL Hostname Validation is performed
def tls(hostname: String): This

Encrypt the connection with SSL.
Encrypt the connection with SSL. Hostname verification will be provided against the given hostname.
def tlsWithoutValidation(): This

Do not perform TLS validation.
Do not perform TLS validation. Probably dangerous.
def toString(): String

Definition Classes
ClientBuilder → AnyRef → Any
def tracer(t: Tracer): This

Specifies a tracer that receives trace events.
Specifies a tracer that receives trace events. See com.twitter.finagle.tracing for details.
def trafficClass(value: Option[Int]): This

Configures the traffic class.
Configures the traffic class.

See also
Transporter.TrafficClass
def unsafeBuild(): Service[Req, Rep]

Construct a Service, with runtime checks for builder completeness.
def unsafeBuildFactory(): ServiceFactory[Req, Rep]

Construct a ServiceFactory, with runtime checks for builder completeness.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def writerIdleTimeout(duration: Duration): This

The maximum time a connection may not have sent any data.

Deprecated Value Members

def build(THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ClientBuilder_DOCUMENTATION: =:=[ThisConfig, FullySpecifiedConfig]): Service[Req, Rep]

Annotations
@deprecated
Deprecated
(Since version 5.0.1) Used for ABI compat
def buildFactory(THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ClientBuilder_DOCUMENTATION: =:=[ThisConfig, FullySpecifiedConfig]): ServiceFactory[Req, Rep]

Annotations
@deprecated
Deprecated
(Since version 5.0.1) Used for ABI compat
def connectionTimeout(duration: Duration): This

Annotations
@deprecated
Deprecated
(Since version 5.0.1) Use tcpConnectTimeout instead
def expFailFast(enabled: Boolean): This

Annotations
@deprecated
Deprecated
(Since version 5.3.10)
def socksProxy(socksProxy: SocketAddress): This

Annotations
@deprecated
Deprecated
(Since version 2014-12-02) Use socksProxy(socksProxy: Option[SocketAddress])
def tracerFactory(t: Tracer): This

Annotations
@deprecated
Deprecated
(Since version 7.0.0) Use tracer() instead
def tracerFactory(factory: Factory): This

Specifies a tracer that receives trace events.
Specifies a tracer that receives trace events. See com.twitter.finagle.tracing for details.

Annotations
@deprecated
Deprecated
(Since version 7.0.0) Use tracer() instead

Related Docs: object ClientBuilder | package builder

class ClientBuilder[Req, Rep, HasCluster, HasCodec, HasHostConnectionLimit] extends AnyRef

Defaults

Type Members

type FullySpecifiedConfig = ClientConfig[Req, Rep, Yes, Yes, Yes]

type This = ClientBuilder[Req, Rep, HasCluster, HasCodec, HasHostConnectionLimit]

type ThisConfig = ClientConfig[Req, Rep, HasCluster, HasCodec, HasHostConnectionLimit]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def baseDtab(baseDtab: () ⇒ Dtab): This

def build()(implicit THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ClientBuilder_DOCUMENTATION: ClientConfigEvidence[HasCluster, HasCodec, HasHostConnectionLimit]): Service[Req, Rep]

def buildFactory()(implicit THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ClientBuilder_DOCUMENTATION: ClientConfigEvidence[HasCluster, HasCodec, HasHostConnectionLimit]): ServiceFactory[Req, Rep]

def channelFactory(cf: ChannelFactory): This

def clone(): AnyRef

def cluster(cluster: Cluster[SocketAddress]): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

def codec[Req1, Rep1](codecFactory: (ClientCodecConfig) ⇒ Codec[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, HasHostConnectionLimit]

def codec[Req1, Rep1](codecFactory: CodecFactory[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, HasHostConnectionLimit]

def codec[Req1, Rep1](codec: Codec[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, HasHostConnectionLimit]

def connectTimeout(duration: Duration): This

def daemon(daemonize: Boolean): This

def dest(name: Name): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

def dest(addr: String): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exceptionCategorizer(exceptionStatsHandler: ExceptionStatsHandler): This

def expHostConnectionBufferSize(size: Int): This

def failFast(enabled: Boolean): This

def failureAccrualFactory(factory: (Timer) ⇒ ServiceFactoryWrapper): This

def failureAccrualParams(pair: (Int, Duration)): This

def finalize(): Unit

final def getClass(): Class[_]

def group(group: Group[SocketAddress]): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

def hashCode(): Int

def hostConnectionCoresize(value: Int): This

def hostConnectionIdleTime(timeout: Duration): This

def hostConnectionLimit(value: Int): ClientBuilder[Req, Rep, HasCluster, HasCodec, Yes]

def hostConnectionMaxIdleTime(timeout: Duration): This

def hostConnectionMaxLifeTime(timeout: Duration): This

def hostConnectionMaxWaiters(nWaiters: Int): This

def hosts(address: SocketAddress): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

def hosts(addrs: Seq[SocketAddress]): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

def hosts(hostnamePortCombinations: String): ClientBuilder[Req, Rep, Yes, HasCodec, HasHostConnectionLimit]

def httpProxy(httpProxy: SocketAddress): This

def httpProxyUsernameAndPassword(credentials: Credentials): This

final def isInstanceOf[T0]: Boolean

def keepAlive(value: Boolean): This

def loadBalancer(loadBalancer: LoadBalancerFactory): This

def logger(logger: Logger): This

def monitor(mFactory: (String) ⇒ Monitor): This

def name(value: String): This

final def ne(arg0: AnyRef): Boolean

def noFailureAccrual: This

final def notify(): Unit

final def notifyAll(): Unit

def params: Params

def readerIdleTimeout(duration: Duration): This

def recvBufferSize(value: Int): This

def reportHostStats(receiver: StatsReceiver): This

def reportTo(receiver: StatsReceiver): This

def requestTimeout(duration: Duration): This

def responseClassifier: ResponseClassifier

def responseClassifier(classifier: ResponseClassifier): This

def retries(value: Int): This

def retryBudget(budget: RetryBudget, backoffSchedule: Stream[Duration]): This

def retryBudget(budget: RetryBudget): This

def retryPolicy(value: RetryPolicy[Try[Nothing]]): This

def sendBufferSize(value: Int): This

def socksProxy(socksProxy: Option[SocketAddress]): This

def socksUsernameAndPassword(credentials: (String, String)): This

def stack[Req1, Rep1](client: StackBasedClient[Req1, Rep1]): ClientBuilder[Req1, Rep1, HasCluster, Yes, Yes]

final def synchronized[T0](arg0: ⇒ T0): T0

def tcpConnectTimeout(duration: Duration): This

def timeout(duration: Duration): This

def tls(sslContext: SSLContext, hostname: Option[String]): This

def tls(sslContext: SSLContext): This

def tls(hostname: String): This