class ServerBuilder[Req, Rep, HasCodec, HasBindTo, HasName] extends AnyRef
A handy Builder for constructing Servers (i.e., binding Services to a port). This class is subclassable. Override copy() and build() to do your own dirty work.
Please see the
Finagle user guide
for information on the preferred with
-style client-construction APIs.
The main class to use is com.twitter.finagle.builder.ServerBuilder, as so
ServerBuilder() .stack(Http.server) .hostConnectionMaxLifeTime(5.minutes) .readTimeout(2.minutes) .name("servicename") .bindTo(new InetSocketAddress(serverPort)) .build(plusOneService)
The ServerBuilder
requires the definition of stack
, bindTo
and name
. In Scala, these are statically type
checked, and in Java the lack of any of the above causes a runtime
error.
The build
method uses an implicit argument to statically
typecheck the builder (to ensure completeness, see above). The Java
compiler cannot provide such implicit, so we provide a separate
function in Java to accomplish this. Thus, the Java code for the
above is
ServerBuilder.safeBuild( plusOneService, ServerBuilder.get() .stack(Http.server()) .hostConnectionMaxLifeTime(5.minutes) .readTimeout(2.minutes) .name("servicename") .bindTo(new InetSocketAddress(serverPort)));
Alternatively, using the unsafeBuild
method on ServerBuilder
verifies the builder dynamically, resulting in a runtime error
instead of a compiler error.
Defaults
The following defaults are applied to servers constructed via ServerBuilder, unless overridden with the corresponding method. These defaults were chosen carefully so as to work well for most use cases. Before changing any of them, make sure that you know exactly how they will affect your application -- these options are typically only changed by expert users.
- openConnectionsThresholds
: None
- maxConcurrentRequests
: Int.MaxValue
- backlog
: OS-defined default value
- See also
The user guide for information on the preferred
with
-style APIs insead.
- Alphabetic
- By Inheritance
- ServerBuilder
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
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 backlog(value: Int): This
-
def
bindTo(address: SocketAddress): ServerBuilder[Req, Rep, HasCodec, Yes, HasName]
To migrate to the Stack-based APIs, use
Server.serve
.To migrate to the Stack-based APIs, use
Server.serve
. For example:import com.twitter.finagle.Http import com.twitter.finagle.Service val service: Service[Req, Rep] = ??? Http.server.serve(address, service)
-
def
build(serviceFactory: ServiceFactory[Req, Rep])(implicit THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ServerBuilder_DOCUMENTATION: ServerConfigEvidence[HasCodec, HasBindTo, HasName]): ListeningServer
Construct the Server, given the provided ServiceFactory.
Construct the Server, given the provided ServiceFactory. This is useful if the protocol is stateful (e.g., requires authentication or supports transactions).
-
def
build(service: Service[Req, Rep])(implicit THE_BUILDER_IS_NOT_FULLY_SPECIFIED_SEE_ServerBuilder_DOCUMENTATION: ServerConfigEvidence[HasCodec, HasBindTo, HasName]): ListeningServer
Construct the Server, given the provided Service.
-
def
cancelOnHangup(yesOrNo: Boolean): This
Cancel pending futures whenever the the connection is shut down.
Cancel pending futures whenever the the connection is shut down. This defaults to true.
To migrate to the Stack-based APIs, use
configured
. For example:import com.twitter.finagle.Http import com.twitter.finagle.filter.MaskCancelFilter Http.server.configured(MaskCancelFilter.Param(!yesOrNo))
- See also
com.twitter.finagle.filter.ServerAdmissionControl
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
configured[P](paramAndStackParam: (P, Param[P])): This
Java friendly API for configuring the underlying Params.
Java friendly API for configuring the underlying Params.
- paramAndStackParam
Configures the server with a given param represented as the tuple
(param value, stack param instance)
TheTuple2
can often be created by calls to amk(): (P, Stack.Param[P])
method on parameters (see com.twitter.finagle.loadbalancer.LoadBalancerFactory.Param.mk() as an example).
-
def
configured[P](param: P)(implicit stackParam: Param[P]): This
Configure the underlying Params.
Configure the underlying Params.
- param
Configures the server with a given
param
Java users may find it easier to use theTuple2
version below.
-
def
daemon(daemonize: Boolean): This
When true, the server is daemonized.
When true, the server is daemonized. As with java threads, a process can only exit only when all remaining servers are daemonized. False by default.
The default for the Stack-based APIs is for the server to be daemonized.
-
def
enableAdmissionControl(enable: Boolean): This
Configure admission control filters in the server Stack.
Configure admission control filters in the server Stack.
To migrate to the Stack-based APIs, use
configured
. For example:import com.twitter.finagle.Http import com.twitter.finagle.filter.ServerAdmissionControl Http.server.configured(ServerAdmissionControl.Param(enable))
- See also
com.twitter.finagle.filter.ServerAdmissionControl
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
exceptionCategorizer(exceptionStatsHandler: ExceptionStatsHandler): This
Provide an alternative to putting all request exceptions under a "failures" stat.
Provide an alternative to putting all request exceptions under a "failures" stat. Typical implementations may report any cancellations or validation errors separately so success rate considers only valid non cancelled requests.
To migrate to the Stack-based APIs, use
CommonParams.withExceptionStatsHandler
. For example:import com.twitter.finagle.Http Http.server.withExceptionStatsHandler(exceptionStatsHandler)
- exceptionStatsHandler
function to record failure details.
-
def
finalize(): Unit
- Attributes
- protected[java.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()
- def hostConnectionMaxIdleTime(howlong: Duration): This
- def hostConnectionMaxLifeTime(howlong: Duration): This
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def keepAlive(value: Boolean): This
-
def
logChannelActivity(v: Boolean): This
To migrate to the Stack-based APIs, use
ServerTransportParams.verbose
.To migrate to the Stack-based APIs, use
ServerTransportParams.verbose
. For example:import com.twitter.finagle.Http Http.server.withTransport.verbose
-
def
logger(logger: Logger): This
To migrate to the Stack-based APIs, use
configured
.To migrate to the Stack-based APIs, use
configured
. For example:import com.twitter.finagle.Http import com.twitter.finagle.param Http.server.configured(param.Logger(logger))
-
def
maxConcurrentRequests(max: Int): This
Configures the maximum concurrent requests that are admitted by the server at any given time.
Configures the maximum concurrent requests that are admitted by the server at any given time. If the server receives a burst of traffic that exceeds this limit, the burst is rejected with a
FailureFlags.Rejected
exception. Note, this failure signals a graceful rejection which is transmitted to clients by certain protocols in Finagle (e.g. Http, ThriftMux). The limit is global to all sessions.To migrate to the Stack-based APIs, use
ServerAdmissionControlParams.concurrencyLimit
. For example:import com.twitter.finagle.Http Http.server.withAdmissionControl.concurrencyLimit(10, 0)
-
def
monitor(mFactory: (String, SocketAddress) ⇒ Monitor): This
To migrate to the Stack-based APIs, use
CommonParams.withMonitor
.To migrate to the Stack-based APIs, use
CommonParams.withMonitor
. For example:import com.twitter.finagle.Http import com.twitter.util.Monitor val monitor: Monitor = ??? Http.server.withMonitor(monitor)
-
def
name(value: String): ServerBuilder[Req, Rep, HasCodec, HasBindTo, Yes]
To migrate to the Stack-based APIs, use
CommonParams.withLabel
.To migrate to the Stack-based APIs, use
CommonParams.withLabel
. For example:import com.twitter.finagle.Http Http.server.withLabel("my_server")
-
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
params: Params
The underlying Params used for configuration.
-
def
readTimeout(howlong: Duration): This
To migrate to the Stack-based APIs, use
TransportParams.readTimeout
.To migrate to the Stack-based APIs, use
TransportParams.readTimeout
. For example:import com.twitter.finagle.Http Http.server.withTransport.readTimeout(howlong)
-
def
recvBufferSize(value: Int): This
To migrate to the Stack-based APIs, use
ServerTransportParams.receiveBufferSize
.To migrate to the Stack-based APIs, use
ServerTransportParams.receiveBufferSize
. For example:import com.twitter.finagle.Http Http.server.withTransport.receiveBufferSize(value)
-
def
reportTo(receiver: StatsReceiver): This
To migrate to the Stack-based APIs, use
CommonParams.withStatsReceiver
.To migrate to the Stack-based APIs, use
CommonParams.withStatsReceiver
. For example:import com.twitter.finagle.Http Http.server.withStatsReceiver(receiver)
-
def
requestTimeout(howlong: Duration): This
To migrate to the Stack-based APIs, use
CommonParams.withRequestTimeout
.To migrate to the Stack-based APIs, use
CommonParams.withRequestTimeout
. For example:import com.twitter.finagle.Http Http.server.withRequestTimeout(howlong)
- Note
if the request is not complete after
howlong
, the work that is in progress will be interrupted via Future.raise.
-
def
responseClassifier: ResponseClassifier
The currently configured com.twitter.finagle.service.ResponseClassifier.
The currently configured com.twitter.finagle.service.ResponseClassifier.
- Note
If unspecified, the default classifier is com.twitter.finagle.service.ResponseClassifier.Default.
-
def
responseClassifier(classifier: 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
To migrate to the Stack-based APIs, use
CommonParams.withResponseClassifier
. For example:import com.twitter.finagle.Http Http.server.withResponseClassifier(classifier)
- 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.
-
def
sendBufferSize(value: Int): This
To migrate to the Stack-based APIs, use
ServerTransportParams.sendBufferSize
.To migrate to the Stack-based APIs, use
ServerTransportParams.sendBufferSize
. For example:import com.twitter.finagle.Http Http.server.withTransport.sendBufferSize(value)
-
def
stack[Req1, Rep1](server: StackBasedServer[Req1, Rep1]): ServerBuilder[Req1, Rep1, Yes, HasBindTo, HasName]
Overrides the stack and com.twitter.finagle.Server that will be used by this builder.
Overrides the stack and com.twitter.finagle.Server that will be used by this builder.
- server
A StackBasedServer representation of a com.twitter.finagle.Server.
server
is materialized with the state of configuration whenbuild
is called. There is no guarantee that all builder parameters will be used by the resultantServer
; it is up to the discretion ofserver
itself and the protocol implementation.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tls(config: SslServerConfiguration, engineFactory: SslServerEngineFactory, sessionVerifier: SslServerSessionVerifier): This
Encrypt the connection with SSL/TLS.
Encrypt the connection with SSL/TLS.
To migrate to the Stack-based APIs, use
ServerTransportParams.tls
. For example:import com.twitter.finagle.Http Http.server.withTransport.tls(config, engineFactory, sessionVerifier)
-
def
tls(config: SslServerConfiguration, sessionVerifier: SslServerSessionVerifier): This
Encrypt the connection with SSL/TLS.
Encrypt the connection with SSL/TLS.
To migrate to the Stack-based APIs, use
ServerTransportParams.tls
. For example:import com.twitter.finagle.Http Http.server.withTransport.tls(config, sessionVerifier)
-
def
tls(config: SslServerConfiguration, engineFactory: SslServerEngineFactory): This
Encrypt the connection with SSL/TLS.
Encrypt the connection with SSL/TLS.
To migrate to the Stack-based APIs, use
ServerTransportParams.tls
. For example:import com.twitter.finagle.Http Http.server.withTransport.tls(config, engineFactory)
-
def
tls(config: SslServerConfiguration): This
Encrypt the connection with SSL/TLS.
Encrypt the connection with SSL/TLS.
To migrate to the Stack-based APIs, use
ServerTransportParams.tls
. For example:import com.twitter.finagle.Http Http.server.withTransport.tls(config)
-
def
toString(): String
- Definition Classes
- ServerBuilder → AnyRef → Any
-
def
tracer(t: Tracer): This
To migrate to the Stack-based APIs, use
CommonParams.withTracer
.To migrate to the Stack-based APIs, use
CommonParams.withTracer
. For example:import com.twitter.finagle.Http Http.server.withTracer(t)
-
def
trafficClass(value: Option[Int]): This
Configures the traffic class.
Configures the traffic class.
To migrate to the Stack-based APIs, use
configured
. For example:import com.twitter.finagle.Http import com.twitter.finagle.server.Listener Http.server.configured(Listener.TrafficClass(value))
- See also
Listener.TrafficClass
-
def
unsafeBuild(service: Service[Req, Rep]): ListeningServer
Construct a Service, with runtime checks for builder completeness.
-
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
- @native() @throws( ... )
-
def
writeCompletionTimeout(howlong: Duration): This
To migrate to the Stack-based APIs, use
TransportParams.writeTimeout
.To migrate to the Stack-based APIs, use
TransportParams.writeTimeout
. For example:import com.twitter.finagle.Http Http.server.withTransport.writeTimeout(howlong)