Client

Instance Constructors

new Client(stack: Stack[ServiceFactory[Request, Response]] = Client.stack, params: Params = Client.params)

Type Members

type Context = TransportContext

Attributes
protected
type In = Any

Attributes
protected
type Out = Any

Attributes
protected

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 clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def configured[P](psp: (P, Param[P])): Client

Definition Classes
Client → EndpointerStackClient → StackClient → Parameterized
def configured[P](p: P)(implicit arg0: Param[P]): Client

Definition Classes
EndpointerStackClient → StackClient → Parameterized
def configuredParams(newParams: Params): Client

Definition Classes
Client → EndpointerStackClient → StackClient → Parameterized
def copy1(stack: Stack[ServiceFactory[Request, Response]] = this.stack, params: Params = this.params): Client

Attributes
protected
Definition Classes
Client → EndpointerStackClient
def endpointer: Stackable[ServiceFactory[Request, Response]]

Attributes
protected
Definition Classes
Client → EndpointerStackClient
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def filtered(filter: Filter[Request, Response, Request, Response]): Client

Definition Classes
Client → EndpointerStackClient
def finalize(): Unit

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

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def methodBuilder(dest: Name): MethodBuilder

Create a http.MethodBuilder for a given destination.
Create a http.MethodBuilder for a given destination.

See also
user guide
def methodBuilder(dest: String): MethodBuilder

Create a http.MethodBuilder for a given destination.
Create a http.MethodBuilder for a given destination.

See also
user guide
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newClient(dest: Name, label0: String): ServiceFactory[Request, Response]

Definition Classes
Client → EndpointerStackClient → Client
final def newClient(dest: String, label: String): ServiceFactory[Request, Response]

Definition Classes
Client
final def newClient(dest: String): ServiceFactory[Request, Response]

Definition Classes
Client
def newService(dest: Name, label: String): Service[Request, Response]

Definition Classes
EndpointerStackClient → Client
final def newService(dest: String, label: String): Service[Request, Response]

Definition Classes
Client
final def newService(dest: String): Service[Request, Response]

Definition Classes
Client
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val params: Params

Definition Classes
Client → StackClient → Parameterized
final def registerTransporter(transporterName: String): Unit

Attributes
protected
Definition Classes
StackClient
val stack: Stack[ServiceFactory[Request, Response]]

Definition Classes
Client → StackClient
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def transformed(t: Transformer): Client

Definition Classes
Client → StackClient → Transformable
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( ... )
val withAdmissionControl: ClientAdmissionControlParams[Client]

Definition Classes
Client → WithClientAdmissionControl
def withDecompression(enabled: Boolean): Client

Enables decompression of http content bodies.
def withExceptionStatsHandler(exceptionStatsHandler: ExceptionStatsHandler): Client

Definition Classes
Client → CommonParams
def withExecutionOffloaded(executor: ExecutorService): Client

Definition Classes
CommonParams
def withExecutionOffloaded(pool: FuturePool): Client

Definition Classes
CommonParams
def withHttp2: Client

Enable HTTP/2
Enable HTTP/2

Note
this will override whatever has been set in the toggle.
def withHttpStats: Client

Enable the collection of HTTP specific metrics.
Enable the collection of HTTP specific metrics. See http.filter.StatsFilter.
def withLabel(label: String): Client

Definition Classes
Client → CommonParams
def withLabels(keywords: String*): Client

Definition Classes
CommonParams
val withLoadBalancer: DefaultLoadBalancingParams[Client]

Definition Classes
Client → WithDefaultLoadBalancer
def withMaxHeaderSize(size: StorageUnit): Client

For HTTP1*, configures the max size of headers For HTTP2, sets the MAX_HEADER_LIST_SIZE setting which is the maximum number of uncompressed bytes of header name/values.
For HTTP1*, configures the max size of headers For HTTP2, sets the MAX_HEADER_LIST_SIZE setting which is the maximum number of uncompressed bytes of header name/values. These may be set independently via the .configured API.
def withMaxInitialLineSize(size: StorageUnit): Client

Configures the maximum initial line length the client can receive from a server.
def withMaxResponseSize(size: StorageUnit): Client

Configures the maximum response size that client can receive.
def withMonitor(monitor: Monitor): Client

Definition Classes
Client → CommonParams
def withNoHttp2: Client

Disable HTTP/2
Disable HTTP/2

Note
this will override whatever has been set in the toggle.
def withParams(params: Params): Client

Definition Classes
EndpointerStackClient → StackClient → Parameterized
def withRequestTimeout(timeout: Duration): Client

Definition Classes
Client → CommonParams
def withRequestTimeout(timeout: Tunable[Duration]): Client

Definition Classes
CommonParams
def withResponseClassifier(responseClassifier: ResponseClassifier): Client

Definition Classes
Client → CommonParams
def withRetryBackoff(backoff: Stream[Duration]): Client

Definition Classes
Client → ClientParams
def withRetryBudget(budget: RetryBudget): Client

Definition Classes
Client → ClientParams
val withSession: ClientSessionParams[Client]

Definition Classes
Client → WithClientSession
val withSessionPool: SessionPoolingParams[Client]

Definition Classes
Client → WithSessionPool
val withSessionQualifier: SessionQualificationParams[Client]

Definition Classes
Client → WithSessionQualifier
def withStack(fn: (Stack[ServiceFactory[Request, Response]]) ⇒ Stack[ServiceFactory[Request, Response]]): Client

Definition Classes
Client → EndpointerStackClient → StackClient
def withStack(stack: Stack[ServiceFactory[Request, Response]]): Client

Definition Classes
Client → EndpointerStackClient → StackClient
def withStatsReceiver(statsReceiver: StatsReceiver): Client

Definition Classes
Client → CommonParams
def withStreaming(fixedLengthStreamedAfter: StorageUnit): Client

Streaming allows applications to work with HTTP messages that have large (or infinite) content bodies.
Streaming allows applications to work with HTTP messages that have large (or infinite) content bodies.
This method configures fixedLengthStreamedAfter limit, which effectively turns on streaming (think withStreaming(true)). The fixedLengthStreamedAfter, however, disables streaming for sufficiently small messages of known fixed length.
If Content-Length of a message does not exceed fixedLengthStreamedAfter it is buffered and its content is available through Request.content or Request.contentString.
Messages without Content-Length header are always streamed regardless of their actual content length and the fixedLengthStreamedAfter value.
Response.isChunked should be used to determine whether a message is streamed (isChunked == true) or buffered (isChunked == false).
def withStreaming(enabled: Boolean): Client

Streaming allows applications to work with HTTP messages that have large (or infinite) content bodies.
Streaming allows applications to work with HTTP messages that have large (or infinite) content bodies.
If enabled is set to true, the message content is available through a com.twitter.io.Reader, which gives the application a handle to the byte stream.
If enabled is set to false, the entire message content is buffered up to maximum allowed message size.
def withTls(hostname: String): Client
def withTlsWithoutValidation: Client
def withTracer(tracer: Tracer): Client

Definition Classes
Client → CommonParams
val withTransport: ClientTransportParams[Client]

Definition Classes
Client → WithClientTransport

Deprecated Value Members

def transformed(f: (Stack[ServiceFactory[Request, Response]]) ⇒ Stack[ServiceFactory[Request, Response]]): Client

Definition Classes
EndpointerStackClient
Annotations
@deprecated
Deprecated
(Since version 2018-10-30) Use withStack(Stack[ServiceFactory[Req, Rep]] => Stack[ServiceFactory[Req, Rep]]) instead

Related Docs: object Client | package Http

case class Client(stack: Stack[ServiceFactory[Request, Response]] = Client.stack, params: Params = Client.params) extends EndpointerStackClient[Request, Response, Client] with WithSessionPool[Client] with WithDefaultLoadBalancer[Client] with Transformable[Client] with Product with Serializable

Instance Constructors

new Client(stack: Stack[ServiceFactory[Request, Response]] = Client.stack, params: Params = Client.params)

Type Members

type Context = TransportContext

type In = Any

type Out = Any

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def configured[P](psp: (P, Param[P])): Client

def configured[P](p: P)(implicit arg0: Param[P]): Client

def configuredParams(newParams: Params): Client

def copy1(stack: Stack[ServiceFactory[Request, Response]] = this.stack, params: Params = this.params): Client

def endpointer: Stackable[ServiceFactory[Request, Response]]

final def eq(arg0: AnyRef): Boolean

def filtered(filter: Filter[Request, Response, Request, Response]): Client

def finalize(): Unit

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def methodBuilder(dest: Name): MethodBuilder

def methodBuilder(dest: String): MethodBuilder

final def ne(arg0: AnyRef): Boolean

def newClient(dest: Name, label0: String): ServiceFactory[Request, Response]

final def newClient(dest: String, label: String): ServiceFactory[Request, Response]

final def newClient(dest: String): ServiceFactory[Request, Response]

def newService(dest: Name, label: String): Service[Request, Response]

final def newService(dest: String, label: String): Service[Request, Response]

final def newService(dest: String): Service[Request, Response]

final def notify(): Unit

final def notifyAll(): Unit

val params: Params

final def registerTransporter(transporterName: String): Unit

val stack: Stack[ServiceFactory[Request, Response]]

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

def transformed(t: Transformer): Client

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

val withAdmissionControl: ClientAdmissionControlParams[Client]

def withDecompression(enabled: Boolean): Client

def withExceptionStatsHandler(exceptionStatsHandler: ExceptionStatsHandler): Client

def withExecutionOffloaded(executor: ExecutorService): Client

def withExecutionOffloaded(pool: FuturePool): Client

def withHttp2: Client

def withHttpStats: Client

def withLabel(label: String): Client

def withLabels(keywords: String*): Client

val withLoadBalancer: DefaultLoadBalancingParams[Client]

def withMaxHeaderSize(size: StorageUnit): Client

def withMaxInitialLineSize(size: StorageUnit): Client

def withMaxResponseSize(size: StorageUnit): Client

def withMonitor(monitor: Monitor): Client

def withNoHttp2: Client

def withParams(params: Params): Client

def withRequestTimeout(timeout: Duration): Client

def withRequestTimeout(timeout: Tunable[Duration]): Client

def withResponseClassifier(responseClassifier: ResponseClassifier): Client

def withRetryBackoff(backoff: Stream[Duration]): Client

def withRetryBudget(budget: RetryBudget): Client

val withSession: ClientSessionParams[Client]

val withSessionPool: SessionPoolingParams[Client]

val withSessionQualifier: SessionQualificationParams[Client]

def withStack(fn: (Stack[ServiceFactory[Request, Response]]) ⇒ Stack[ServiceFactory[Request, Response]]): Client

def withStack(stack: Stack[ServiceFactory[Request, Response]]): Client

def withStatsReceiver(statsReceiver: StatsReceiver): Client

def withStreaming(fixedLengthStreamedAfter: StorageUnit): Client

def withStreaming(enabled: Boolean): Client

def withTls(hostname: String): Client

def withTlsWithoutValidation: Client

def withTracer(tracer: Tracer): Client

val withTransport: ClientTransportParams[Client]

Deprecated Value Members

def transformed(f: (Stack[ServiceFactory[Request, Response]]) ⇒ Stack[ServiceFactory[Request, Response]]): Client

Inherited from Serializable