ServerBuilder

Companion object ServerBuilder

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.

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

ServerBuilder
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

type FullySpecifiedConfig = ServerConfig[Req, Rep, Yes, Yes, Yes]
type This = ServerBuilder[Req, Rep, HasCodec, HasBindTo, HasName]
type ThisConfig = ServerConfig[Req, Rep, HasCodec, HasBindTo, HasName]

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) The Tuple2 can often be created by calls to a mk(): (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 the Tuple2 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 when build is called. There is no guarantee that all builder parameters will be used by the resultant Server; it is up to the discretion of server 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)
```

Packages

ServerBuilder

Companion object ServerBuilder

class ServerBuilder[Req, Rep, HasCodec, HasBindTo, HasName] extends AnyRef

Defaults

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

ServerBuilder 

Companion object ServerBuilder

class ServerBuilder[Req, Rep, HasCodec, HasBindTo, HasName] extends AnyRef

Defaults

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

ServerBuilder