Client

Instance Constructors

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

Type Members

type In = Buf

Attributes
protected
Definition Classes
Client → StdStackClient
type Out = Buf

Attributes
protected
Definition Classes
Client → StdStackClient

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 → StdStackClient → StackClient → Parameterized
def configured[P](p: P)(implicit arg0: Param[P]): Client

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

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

Attributes
protected
Definition Classes
Client → StdStackClient
def endpointer: Stackable[ServiceFactory[Command, Response]]

Attributes
protected
Definition Classes
StdStackClient
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
Client → StdStackClient
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
final def ne(arg0: AnyRef): Boolean

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

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

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

Definition Classes
Client
def newDispatcher(transport: Transport[In, Out]): Service[Command, Response]

Attributes
protected
Definition Classes
Client → StdStackClient
def newRichClient(dest: String): memcached.Client

Constructs a memcached.Client that dispatches requests over dest.
Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.

Definition Classes
MemcachedRichClient
def newRichClient(dest: Name, label: String): memcached.Client

Constructs a memcached.Client that dispatches requests over dest.
Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.
Argument label is used to assign a label to this client. The label is used to scope stats, etc.

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

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

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

Definition Classes
Client
def newTransporter(): Transporter[In, Out]

Attributes
protected
Definition Classes
Client → StdStackClient
def newTwemcacheClient(dest: Name, label: String): TwemcacheClient

Constructs a memcached.Client that dispatches requests over dest.
Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.
Argument label is used to assign a label to this client. The label is used to scope stats, etc.

Definition Classes
Client → MemcachedRichClient
def newTwemcacheClient(dest: String): TwemcacheClient

Constructs a memcached.Client that dispatches requests over dest.
Constructs a memcached.Client that dispatches requests over dest. When dest resolves to multiple hosts, the hosts are hashed across a ring with key affinity. The key hashing algorithm can be configured via the withKeyHasher method on Memcached.client. Failing hosts can be ejected from the hash ring if withEjectFailedHost is set to true. Note, the current implementation only supports bound Names.

Definition Classes
MemcachedRichClient
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val params: Params

Definition Classes
Client → StackClient → Parameterized
val stack: Stack[ServiceFactory[Command, Response]]

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

Definition Classes
AnyRef
def transformed(f: (Stack[ServiceFactory[Command, Response]]) ⇒ Stack[ServiceFactory[Command, Response]]): Client

Definition Classes
StdStackClient
def transformed(t: Transformer): StackClient[Command, Response]

Definition Classes
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 withEjectFailedHost(eject: Boolean): Client

Whether to eject cache host from the Ketama ring based on failure accrual.
Whether to eject cache host from the Ketama ring based on failure accrual. By default, this is off. When turning on, keep the following caveat in mind: ejection is based on local failure accrual, so your cluster may get different views of the same cache host. With cache updates, this can introduce inconsistency in cache data. In many cases, it's better to eject cache host from a separate mechanism that's based on a global view.
def withExceptionStatsHandler(exceptionStatsHandler: ExceptionStatsHandler): Client

Definition Classes
Client → CommonParams
def withKeyHasher(hasher: KeyHasher): Client

Defines the hash function to use for partitioned clients when mapping keys to partitions.
def withLabel(label: String): Client

Definition Classes
Client → CommonParams
val withLoadBalancer: ConcurrentLoadBalancingParams[Client]

Definition Classes
Client → WithConcurrentLoadBalancer
def withMonitor(monitor: Monitor): Client

Definition Classes
Client → CommonParams
def withNumReps(reps: Int): Client

Duplicate each node across the hash ring according to reps.
Duplicate each node across the hash ring according to reps.

See also
com.twitter.hashing.KetamaDistributor for more details.
def withParams(params: Params): Client

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

Definition Classes
Client → 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 withSessionQualifier: SessionQualificationParams[Client]

Definition Classes
Client → WithSessionQualifier
def withStack(stack: Stack[ServiceFactory[Command, Response]]): Client

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

Definition Classes
Client → CommonParams
def withTracer(tracer: Tracer): Client

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

Definition Classes
Client → WithClientTransport

Deprecated Value Members

final def newClient(dest: Group[SocketAddress]): ServiceFactory[Command, Response]

Definition Classes
Client
Annotations
@deprecated
Deprecated
(Since version 6.7.x) Use destination names
final def newService(dest: Group[SocketAddress]): Service[Command, Response]

Definition Classes
Client
Annotations
@deprecated
Deprecated
(Since version 6.7.x) Use destination names

Related Docs: object Client | package Memcached

case class Client(stack: Stack[ServiceFactory[Command, Response]] = Client.newStack, params: Params = Client.defaultParams) extends StdStackClient[Command, Response, Client] with WithConcurrentLoadBalancer[Client] with MemcachedRichClient with Product with Serializable

Instance Constructors

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

Type Members

type In = Buf

type Out = Buf

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[Command, Response]] = this.stack, params: Params = this.params): Client

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

final def eq(arg0: AnyRef): Boolean

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

def finalize(): Unit

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

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

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

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

def newDispatcher(transport: Transport[In, Out]): Service[Command, Response]

def newRichClient(dest: String): memcached.Client

def newRichClient(dest: Name, label: String): memcached.Client

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

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

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

def newTransporter(): Transporter[In, Out]

def newTwemcacheClient(dest: Name, label: String): TwemcacheClient

def newTwemcacheClient(dest: String): TwemcacheClient

final def notify(): Unit

final def notifyAll(): Unit

val params: Params

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

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

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

def transformed(t: Transformer): StackClient[Command, Response]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val withAdmissionControl: ClientAdmissionControlParams[Client]

def withEjectFailedHost(eject: Boolean): Client

def withExceptionStatsHandler(exceptionStatsHandler: ExceptionStatsHandler): Client

def withKeyHasher(hasher: KeyHasher): Client

def withLabel(label: String): Client

val withLoadBalancer: ConcurrentLoadBalancingParams[Client]

def withMonitor(monitor: Monitor): Client

def withNumReps(reps: Int): Client

def withParams(params: Params): Client

def withRequestTimeout(timeout: Duration): Client

def withResponseClassifier(responseClassifier: ResponseClassifier): Client

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

def withRetryBudget(budget: RetryBudget): Client

val withSession: ClientSessionParams[Client]

val withSessionQualifier: SessionQualificationParams[Client]

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

def withStatsReceiver(statsReceiver: StatsReceiver): Client

def withTracer(tracer: Tracer): Client

val withTransport: ClientTransportParams[Client]

Deprecated Value Members

final def newClient(dest: Group[SocketAddress]): ServiceFactory[Command, Response]

final def newService(dest: Group[SocketAddress]): Service[Command, Response]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from MemcachedRichClient

Inherited from WithConcurrentLoadBalancer[Client]

Inherited from StdStackClient[Command, Response, Client]

Inherited from WithSessionQualifier[Client]

Inherited from WithClientSession[Client]

Inherited from WithClientTransport[Client]

Inherited from WithClientAdmissionControl[Client]