trait ListeningStackServer[Req, Rep, This <: ListeningStackServer[Req, Rep, This]] extends StackServer[Req, Rep] with Parameterized[This] with Transformable[This] with CommonParams[This] with WithServerTransport[This] with WithServerSession[This] with WithServerAdmissionControl[This]
The standard template for creating a concrete representation of a StackServer.
- Self Type
- This
- See also
StdStackServer for a further refined
StackServer
template which uses the transport + dispatcher pattern.
- Alphabetic
- By Inheritance
- ListeningStackServer
- WithServerAdmissionControl
- WithServerSession
- WithServerTransport
- CommonParams
- StackServer
- StackBasedServer
- Transformable
- Parameterized
- Server
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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
-
abstract
def
newListeningServer(serviceFactory: ServiceFactory[Req, Rep], addr: SocketAddress)(trackSession: (ClientConnection) ⇒ Unit): ListeningServer
Constructs a new
ListeningServer
from theServiceFactory
.Constructs a new
ListeningServer
from theServiceFactory
. Each new session is passed to thetrackSession
function exactly once to facilitate connection resource management.- 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
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
configured[P](psp: (P, Param[P])): This
Creates a new StackServer with parameter
psp._1
and Stack Param typepsp._2
.Creates a new StackServer with parameter
psp._1
and Stack Param typepsp._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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
serve(addr: SocketAddress, factory: ServiceFactory[Req, Rep]): ListeningServer
Serve
service
ataddr
Serve
service
ataddr
- Definition Classes
- ListeningStackServer → Server
-
final
def
serve(addr: String, service: Service[Req, Rep]): ListeningServer
Serve
service
ataddr
Serve
service
ataddr
- Definition Classes
- Server
-
final
def
serve(addr: String, service: ServiceFactory[Req, Rep]): ListeningServer
Serve
service
ataddr
Serve
service
ataddr
- Definition Classes
- Server
-
final
def
serve(addr: SocketAddress, service: Service[Req, Rep]): ListeningServer
Serve
service
ataddr
Serve
service
ataddr
- Definition Classes
- Server
-
def
serveAndAnnounce(name: String, service: Service[Req, Rep]): ListeningServer
Serve
service
ataddr
and announce withname
.Serve
service
ataddr
and announce withname
. Announcements will be removed when the service is closed. Omitting theaddr
will bind to an ephemeral port.- Definition Classes
- Server
-
def
serveAndAnnounce(name: String, service: ServiceFactory[Req, Rep]): ListeningServer
Serve
service
ataddr
and announce withname
.Serve
service
ataddr
and announce withname
. Announcements will be removed when the service is closed. Omitting theaddr
will bind to an ephemeral port.- Definition Classes
- Server
-
def
serveAndAnnounce(name: String, addr: String, service: Service[Req, Rep]): ListeningServer
Serve
service
ataddr
and announce withname
.Serve
service
ataddr
and announce withname
. Announcements will be removed when the service is closed. Omitting theaddr
will bind to an ephemeral port.- Definition Classes
- Server
-
def
serveAndAnnounce(name: String, addr: String, service: ServiceFactory[Req, Rep]): ListeningServer
Serve
service
ataddr
and announce withname
.Serve
service
ataddr
and announce withname
. Announcements will be removed when the service is closed. Omitting theaddr
will bind to an ephemeral port.- Definition Classes
- Server
-
def
serveAndAnnounce(name: String, addr: SocketAddress, service: Service[Req, Rep]): ListeningServer
Serve
service
ataddr
and announce withname
.Serve
service
ataddr
and announce withname
. Announcements will be removed when the service is closed. Omitting theaddr
will bind to an ephemeral port.- Definition Classes
- Server
-
def
serveAndAnnounce(name: String, addr: SocketAddress, service: ServiceFactory[Req, Rep]): ListeningServer
Serve
service
ataddr
and announce withname
.Serve
service
ataddr
and announce withname
. Announcements will be removed when the service is closed. Omitting theaddr
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
-
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( ... ) @native()
-
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
withExecutionOffloaded(executor: ExecutorService): This
Configures this server or client to shift user-defined computation (com.twitter.util.Future callbacks and transformations) off of IO threads into a given ExecutorService.
Configures this server or client to shift user-defined computation (com.twitter.util.Future callbacks and transformations) off of IO threads into a given ExecutorService.
By default, Finagle executes all futures in the IO threads, minimizing context switches. Given there is usually a fixed number of IO threads shared across a JVM process, it's critically important to ensure they aren't being blocked by the application code, affecting system's responsiveness. Shifting application-level work onto a dedicated FuturePool or ExecutorService offloads IO threads, which may improve throughput in CPU-bound systems.
As always, run your own tests before enabling this feature.
- Definition Classes
- CommonParams
-
def
withExecutionOffloaded(pool: FuturePool): This
Configures this server or client to shift user-defined computation (com.twitter.util.Future callbacks and transformations) off of IO threads into a given FuturePool.
Configures this server or client to shift user-defined computation (com.twitter.util.Future callbacks and transformations) off of IO threads into a given FuturePool.
By default, Finagle executes all futures in the IO threads, minimizing context switches. Given there is usually a fixed number of IO threads shared across a JVM process, it's critically important to ensure they aren't being blocked by the application code, affecting system's responsiveness. Shifting application-level work onto a dedicated FuturePool or ExecutorService offloads IO threads, which may improve throughput in CPU-bound systems.
As always, run your own tests before enabling this feature.
- 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
withLabels(keywords: String*): This
- 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).
Monitors are Finagle's out-of-band exception reporters. Whenever an exception is thrown on a request path, it's reported to the monitor. The default monitor implementation, com.twitter.finagle.util.DefaultMonitor, logs these exceptions.
Monitors are wired into the server or client stacks via com.twitter.finagle.filter.MonitorFilter and are applied to the following kinds of exceptions:
- Synchronous exceptions thrown on request path,
Service.apply(request)
- Asynchronous exceptions (failed futures) thrown on request path,
Service.apply(request)
- Exceptions thrown from
respond
,onSuccess
,onFailure
future callbacks - Fatal exceptions thrown from
map
,flatMap
,transform
future continuations
Put it this way, we apply
Monitor.handle
to an exception if we would otherwise "lose" it, i.e. when it's not connected to theFuture
, nor is it connected to the call stack.You can compose multiple monitors if you want to extend or override the standard behavior, defined in
DefaultMonitor
.import com.twitter.util.Monitor val consoleMonitor = new Monitor { def handle(exc: Throwable): Boolean = { Console.err.println(exc.toString) false // continue handling with the next monitor (usually DefaultMonitor) } } $.withMonitor(consoleMonitor)
Returning
true
form within a monitor effectively terminates the monitor chain so no exceptions are propagated down to the next monitor.- Definition Classes
- CommonParams
- Synchronous exceptions thrown on request path,
-
def
withParams(params: Params): This
Creates a new StackServer with
params
used to configure this StackServer'sstack
.Creates a new StackServer with
params
used to configure this StackServer'sstack
.- 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 ofNone
, 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 ofNone
, 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.
-
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: ServerSessionParams[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 server'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
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
withStack(Stack)
Example: -
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 aFunction1
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
- Note
if you supply com.twitter.finagle.tracing.NullTracer, no trace information will be written, but this does not disable Finagle from propagating trace information. Instead, if traces are being aggregated across your fleet, it will orphan subsequent spans.
-
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