Client

Instance Constructors

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

Type Members

type In = Response

Attributes
protected
Definition Classes
Client → PushStackClient
type Out = Command

Attributes
protected
Definition Classes
Client → PushStackClient
type SessionT = PipeliningClientPushSession[Response, Command]

Attributes
protected
Definition Classes
Client → PushStackClient

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
EndpointerStackClient → StackClient → Parameterized
def connectionsPerEndpoint(connections: Int): Client

Configures the number of concurrent connections a single endpoint has.
Configures the number of concurrent connections a single endpoint has. The connections are load balanced over which allows the pipelined client to avoid head-of-line blocking and reduce its latency.
We've empirically found that two is a good default for this, but it can be increased at the cost of additional connection overhead.
def copy1(stack: Stack[ServiceFactory[Command, Response]], params: Params): Client

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

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

Definition Classes
AnyRef
def filtered(filter: Filter[Command, Response, Command, 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
def injectors: Seq[ClientParamsInjector]

Attributes
protected
Definition Classes
EndpointerStackClient
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
EndpointerStackClient → 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 newPushTransporter(sa: SocketAddress): PushTransporter[Response, Command]

Attributes
protected
Definition Classes
Client → PushStackClient
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
EndpointerStackClient → 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 newSession(handle: PushChannelHandle[Response, Command]): Future[SessionT]

Attributes
protected
Definition Classes
Client → PushStackClient
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
final def registerTransporter(transporterName: String): Unit

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

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

Definition Classes
AnyRef
def toService(session: SessionT): Future[Service[Command, Response]]

Attributes
protected
Definition Classes
Client → PushStackClient
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

Definition Classes
Client → WithPartitioningStrategy
def withExceptionStatsHandler(exceptionStatsHandler: ExceptionStatsHandler): Client

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

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

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

Definition Classes
Client → WithPartitioningStrategy
def withLabel(label: String): Client

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

Definition Classes
CommonParams
def withMonitor(monitor: Monitor): Client

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

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

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

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

Definition Classes
Client → EndpointerStackClient → 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

def transformed(f: (Stack[ServiceFactory[Command, Response]]) ⇒ Stack[ServiceFactory[Command, 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 Memcached

case class Client(stack: Stack[ServiceFactory[Command, Response]] = Client.stack, params: Params = Client.params) extends PushStackClient[Command, Response, Client] with WithPartitioningStrategy[Client] with MemcachedRichClient with Product with Serializable

Instance Constructors

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

Type Members

type In = Response

type Out = Command

type SessionT = PipeliningClientPushSession[Response, Command]

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 connectionsPerEndpoint(connections: Int): Client

def copy1(stack: Stack[ServiceFactory[Command, Response]], params: Params): Client

final 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[_]

def injectors: Seq[ClientParamsInjector]

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 newPushTransporter(sa: SocketAddress): PushTransporter[Response, Command]

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 newSession(handle: PushChannelHandle[Response, Command]): Future[SessionT]

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

def newTwemcacheClient(dest: String): TwemcacheClient

final def notify(): Unit

final def notifyAll(): Unit

val params: Params

final def registerTransporter(transporterName: String): Unit

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

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

def toService(session: SessionT): Future[Service[Command, Response]]

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 withExecutionOffloaded(pool: FuturePool): Client

def withExecutionOffloaded(executor: ExecutorService): Client

def withKeyHasher(hasher: KeyHasher): Client

def withLabel(label: String): Client

def withLabels(keywords: String*): Client

def withMonitor(monitor: Monitor): Client

def withNumReps(reps: Int): 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 withSessionQualifier: SessionQualificationParams[Client]

def withStack(fn: (Stack[ServiceFactory[Command, Response]]) ⇒ Stack[ServiceFactory[Command, Response]]): 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

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

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals