StdStackServer

Type Members

abstract type Context <: TransportContext

The type of the transport's context.
The type of the transport's context.

Attributes
protected
abstract type In

The type we write into the transport.
The type we write into the transport.

Attributes
protected
abstract type Out

The type we read out of the transport.
The type we read out of the transport.

Attributes
protected

Abstract Value Members

abstract def copy1(stack: Stack[ServiceFactory[Req, Rep]] = this.stack, params: Params = this.params): This

A copy constructor in lieu of defining StackServer as a case class.
A copy constructor in lieu of defining StackServer as a case class.

Attributes
protected
Definition Classes
ListeningStackServer
abstract def newDispatcher(transport: Transport[This.In, This.Out] { type Context <: StdStackServer.this.Context }, service: Service[Req, Rep]): Closable

Defines a dispatcher, a function which binds a transport to a com.twitter.finagle.Service.
Defines a dispatcher, a function which binds a transport to a com.twitter.finagle.Service. Together with a Listener, it forms the foundation of a finagle server. Concrete implementations are expected to specify this.

Attributes
protected
Note
The dispatcher must be prepared to handle the situation where it receives an already-closed transport.
See also
com.twitter.finagle.dispatch.GenSerialServerDispatcher
abstract def newListener(): Listener[This.In, This.Out, This.Context]

Defines a typed com.twitter.finagle.server.Listener for this server.
Defines a typed com.twitter.finagle.server.Listener for this server. Concrete StackServer implementations are expected to specify this.

Attributes
protected
abstract def params: Params

The current parameter map used in this StackServer.
The current parameter map used in this StackServer.

Definition Classes
StackServer → Parameterized
abstract def stack: Stack[ServiceFactory[Req, Rep]]

The current stack used in this StackServer.
The current stack used in this StackServer.

Definition Classes
StackServer

Concrete 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 addServerToRegistry(listenerName: String): Unit

Export info about the listener type to the global registry.
Export info about the listener type to the global registry.
The information about its implementation can then be queried at runtime.

Attributes
protected
Definition Classes
ListeningStackServer
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])): This

Creates a new StackServer with parameter psp._1 and Stack Param type psp._2.
Creates a new StackServer with parameter psp._1 and Stack Param type psp._2.

Definition Classes
ListeningStackServer → StackServer → Parameterized
def configured[P](p: P)(implicit arg0: Param[P]): This

Creates a new StackServer with parameter p.
Creates a new StackServer with parameter p.

Definition Classes
ListeningStackServer → StackServer → Parameterized
def configuredParams(newParams: Params): This

Creates a new StackServer with additional parameters newParams.
Creates a new StackServer with additional parameters newParams.

Definition Classes
ListeningStackServer → StackServer → Parameterized
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
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 hashCode(): Int

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

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def newListeningServer(serviceFactory: ServiceFactory[Req, Rep], addr: SocketAddress)(trackSession: (ClientConnection) ⇒ Unit): ListeningServer

Constructs a new ListeningServer from the ServiceFactory.
Constructs a new ListeningServer from the ServiceFactory. Each new session is passed to the trackSession function exactly once to facilitate connection resource management.

Attributes
protected
Definition Classes
StdStackServer → ListeningStackServer
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def serve(addr: SocketAddress, factory: ServiceFactory[Req, Rep]): ListeningServer

Serve service at addr
Serve service at addr

Definition Classes
ListeningStackServer → Server
final def serve(addr: String, service: Service[Req, Rep]): ListeningServer

Serve service at addr
Serve service at addr

Definition Classes
Server
final def serve(addr: String, service: ServiceFactory[Req, Rep]): ListeningServer

Serve service at addr
Serve service at addr

Definition Classes
Server
final def serve(addr: SocketAddress, service: Service[Req, Rep]): ListeningServer

Serve service at addr
Serve service at addr

Definition Classes
Server
def serveAndAnnounce(name: String, service: Service[Req, Rep]): ListeningServer

Serve service at addr and announce with name.
Serve service at addr and announce with name. Announcements will be removed when the service is closed. Omitting the addr will bind to an ephemeral port.

Definition Classes
Server
def serveAndAnnounce(name: String, service: ServiceFactory[Req, Rep]): ListeningServer

Serve service at addr and announce with name.
Serve service at addr and announce with name. Announcements will be removed when the service is closed. Omitting the addr will bind to an ephemeral port.

Definition Classes
Server
def serveAndAnnounce(name: String, addr: String, service: Service[Req, Rep]): ListeningServer

Serve service at addr and announce with name.
Serve service at addr and announce with name. Announcements will be removed when the service is closed. Omitting the addr will bind to an ephemeral port.

Definition Classes
Server
def serveAndAnnounce(name: String, addr: String, service: ServiceFactory[Req, Rep]): ListeningServer

Serve service at addr and announce with name.
Serve service at addr and announce with name. Announcements will be removed when the service is closed. Omitting the addr will bind to an ephemeral port.

Definition Classes
Server
def serveAndAnnounce(name: String, addr: SocketAddress, service: Service[Req, Rep]): ListeningServer

Serve service at addr and announce with name.
Serve service at addr and announce with name. Announcements will be removed when the service is closed. Omitting the addr will bind to an ephemeral port.

Definition Classes
Server
def serveAndAnnounce(name: String, addr: SocketAddress, service: ServiceFactory[Req, Rep]): ListeningServer

Serve service at addr and announce with name.
Serve service at addr and announce with name. Announcements will be removed when the service is closed. Omitting the addr will bind to an ephemeral port.

Definition Classes
Server
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def transformed(t: Stack.Transformer): This

Definition Classes
ListeningStackServer → StackServer → Transformable
See also
withStack
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: ServerAdmissionControlParams[This]

An entry point for configuring the servers' admission control.
An entry point for configuring the servers' admission control.

Definition Classes
WithServerAdmissionControl
def withExceptionStatsHandler(exceptionStatsHandler: ExceptionStatsHandler): This

Configures this server or client with given exception stats handler.
Configures this server or client with given exception stats handler.

Definition Classes
CommonParams
def withLabel(label: String): This

Configures this server or client with given label (default: empty string).
Configures this server or client with given label (default: empty string).
The label value is used for stats reporting to scope stats reported from different clients/servers to a single stats receiver.

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

Configures this server or client with given util.Monitor (default: com.twitter.finagle.util.DefaultMonitor).
Configures this server or client with given util.Monitor (default: com.twitter.finagle.util.DefaultMonitor).

Definition Classes
CommonParams
def withParams(params: Params): This

Creates a new StackServer with params used to configure this StackServer's stack.
Creates a new StackServer with params used to configure this StackServer's stack.

Definition Classes
ListeningStackServer → StackServer → Parameterized
def withRequestTimeout(timeout: Tunable[Duration]): This

Configures the Tunable request timeout of this server or client (if applying the Tunable produces a value of None, an unbounded timeout is used for the request).
Configures the Tunable request timeout of this server or client (if applying the Tunable produces a value of None, an unbounded timeout is used for the request).
If the request has not completed within the Duration resulting from timeout.apply(), the pending work will be interrupted via com.twitter.util.Future.raise.
Client's Request Timeout
The client request timeout is the maximum amount of 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.
Server's Request Timeout
The server request timeout is the maximum amount of time, a server is allowed to spend handling the incoming request. Using the Finagle terminology, this is an amount of time after which a non-satisfied future returned from the user-defined service times out.

Definition Classes
CommonParams
See also
https://twitter.github.io/finagle/guide/Clients.html#timeouts-expiration and https://twitter.github.io/finagle/guide/Configuration.html#tunables
def withRequestTimeout(timeout: Duration): This

Configures the request timeout of this server or client (default: unbounded).
Configures the request timeout of this server or client (default: unbounded).
If the request has not completed within the given timeout, the pending work will be interrupted via com.twitter.util.Future.raise.
Client's Request Timeout
The client request timeout is the maximum amount of 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.
Server's Request Timeout
The server request timeout is the maximum amount of time, a server is allowed to spend handling the incoming request. Using the Finagle terminology, this is an amount of time after which a non-satisfied future returned from the user-defined service times out.

Definition Classes
CommonParams
See also
https://twitter.github.io/finagle/guide/Clients.html#timeouts-expiration
def withResponseClassifier(responseClassifier: 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 responses. 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 server that returns a response with a 500 status code. To Finagle this is a successful request/response. However, the application developer may want to treat all 500 status codes as failures and can do so via setting a com.twitter.finagle.service.ResponseClassifier.
ResponseClassifier is a PartialFunction and as such multiple classifiers can be composed together via PartialFunction.orElse.
Response classification is independently configured on the client and server. For client-side response classification using com.twitter.finagle.builder.ClientBuilder, see com.twitter.finagle.builder.ClientBuilder.responseClassifier

Definition Classes
CommonParams
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.
val withSession: SessionParams[This]

An entry point for configuring the client's sessions.
An entry point for configuring the client's sessions.
Session might be viewed as logical connection that wraps a physical connection (i.e., transport) and controls its lifecycle. Sessions are used in Finagle to maintain liveness, requests cancellation, draining, and many more.
The default setup for a Finagle client's sessions is to not put any timeouts on it.

Definition Classes
WithServerSession
def withStack(fn: (Stack[ServiceFactory[Req, Rep]]) ⇒ Stack[ServiceFactory[Req, Rep]]): This

A new StackServer using the function to create a new Stack.
A new StackServer using the function to create a new Stack.
The input to fn is the client's current stack. This API allows for easier usage when writing code that uses method chaining.
This method is similar to transformed while providing easier API ergonomics for one-off Stack changes.
Definition Classes
ListeningStackServer → StackServer
Example:
1. From Scala:
  import com.twitter.finagle.Http Http.server.withStack(_.prepend(MyStackModule))
  From Java:
  import com.twitter.finagle.Http; import static com.twitter.util.Function.func; Http.server().withStack(func(stack -> stack.prepend(MyStackModule)));
See also
transformed
withStack(Stack)
def withStack(stack: Stack[ServiceFactory[Req, Rep]]): This

A new StackServer with the provided Stack.
A new StackServer with the provided Stack.

Definition Classes
ListeningStackServer → StackServer
See also
withStack that takes a Function1 for a more ergonomic API when used with method chaining.
def withStatsReceiver(statsReceiver: StatsReceiver): This

Configures this server or client with given stats.StatsReceiver (default: stats.DefaultStatsReceiver).
Configures this server or client with given stats.StatsReceiver (default: stats.DefaultStatsReceiver).

Definition Classes
CommonParams
def withTracer(tracer: Tracer): This

Configures this server or client with given tracing.Tracer (default: com.twitter.finagle.tracing.DefaultTracer).
Configures this server or client with given tracing.Tracer (default: com.twitter.finagle.tracing.DefaultTracer).

Definition Classes
CommonParams
val withTransport: ServerTransportParams[This]

An entry point for configuring servers' com.twitter.finagle.transport.Transport.
An entry point for configuring servers' com.twitter.finagle.transport.Transport.
Transport is a Finagle abstraction over the network connection (i.e., a TCP connection).

Definition Classes
WithServerTransport

Related Doc: package server

trait StdStackServer[Req, Rep, This <: StdStackServer[Req, Rep, This]] extends ListeningStackServer[Req, Rep, This]

Type Members

abstract type Context <: TransportContext

abstract type In

abstract type Out

Abstract Value Members

abstract def copy1(stack: Stack[ServiceFactory[Req, Rep]] = this.stack, params: Params = this.params): This

abstract def newDispatcher(transport: Transport[This.In, This.Out] { type Context <: StdStackServer.this.Context }, service: Service[Req, Rep]): Closable

abstract def newListener(): Listener[This.In, This.Out, This.Context]

abstract def params: Params

abstract def stack: Stack[ServiceFactory[Req, Rep]]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def addServerToRegistry(listenerName: String): Unit

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

def configuredParams(newParams: Params): This

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def newListeningServer(serviceFactory: ServiceFactory[Req, Rep], addr: SocketAddress)(trackSession: (ClientConnection) ⇒ Unit): ListeningServer

final def notify(): Unit

final def notifyAll(): Unit

def serve(addr: SocketAddress, factory: ServiceFactory[Req, Rep]): ListeningServer

final def serve(addr: String, service: Service[Req, Rep]): ListeningServer

final def serve(addr: String, service: ServiceFactory[Req, Rep]): ListeningServer

final def serve(addr: SocketAddress, service: Service[Req, Rep]): ListeningServer

def serveAndAnnounce(name: String, service: Service[Req, Rep]): ListeningServer

def serveAndAnnounce(name: String, service: ServiceFactory[Req, Rep]): ListeningServer

def serveAndAnnounce(name: String, addr: String, service: Service[Req, Rep]): ListeningServer

def serveAndAnnounce(name: String, addr: String, service: ServiceFactory[Req, Rep]): ListeningServer

def serveAndAnnounce(name: String, addr: SocketAddress, service: Service[Req, Rep]): ListeningServer

def serveAndAnnounce(name: String, addr: SocketAddress, service: ServiceFactory[Req, Rep]): ListeningServer

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

def toString(): String

def transformed(t: Stack.Transformer): This

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val withAdmissionControl: ServerAdmissionControlParams[This]

def withExceptionStatsHandler(exceptionStatsHandler: ExceptionStatsHandler): This

def withLabel(label: String): This

def withMonitor(monitor: Monitor): This

def withParams(params: Params): This

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

Client's Request Timeout

Server's Request Timeout

def withRequestTimeout(timeout: Duration): This

Client's Request Timeout

Server's Request Timeout

def withResponseClassifier(responseClassifier: ResponseClassifier): This

val withSession: SessionParams[This]

def withStack(fn: (Stack[ServiceFactory[Req, Rep]]) ⇒ Stack[ServiceFactory[Req, Rep]]): This

def withStack(stack: Stack[ServiceFactory[Req, Rep]]): This

def withStatsReceiver(statsReceiver: StatsReceiver): This

def withTracer(tracer: Tracer): This

val withTransport: ServerTransportParams[This]

Inherited from ListeningStackServer[Req, Rep, This]

Inherited from WithServerAdmissionControl[This]

Inherited from WithServerSession[This]

Inherited from WithServerTransport[This]

Inherited from CommonParams[This]

Inherited from StackServer[Req, Rep]

Inherited from StackBasedServer[Req, Rep]

Inherited from Transformable[This]

Inherited from Parameterized[This]

Inherited from Server[Req, Rep]

Inherited from AnyRef

Inherited from Any

Ungrouped