TwitterServer

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final val MinGrace: Duration

def addAdminRoute(route: Route): Unit

def addAdminRoutes(newRoutes: Seq[Route]): Unit

def addDtabs(): Unit

def addFrameworkModule(module: Module): Unit

def addFrameworkModules(modules: Module*): Unit

def addFrameworkOverrideModules(modules: Module*): Unit

def adminBoundAddress: InetSocketAddress

var adminHttpServer: ListeningServer

val adminPort: Flag[InetSocketAddress]

def afterPostWarmup(): Unit

After postWarmup, all external servers have been started, and we can now enable our health endpoint.

def allowUndefinedFlags: Boolean

val appendFlag: Flag[Boolean]

def args: Array[String]

final def asInstanceOf[T0]: T0

val asyncFlag: Flag[Boolean]

val asyncMaxSizeFlag: Flag[Int]

def await(awaitables: Awaitable[_]*): Unit

Callback to register multiple Awaitable instances for the server to await (block) on.

def await[T <: Awaitable[_]](awaitable: T): Unit

Callback to register an Awaitable instance for the server to await (block) on.

def beforePostWarmup(): Unit

After warmup but before accepting traffic promote to old gen (which triggers gc).

def clone(): AnyRef

final def close(deadline: Time): Future[Unit]

def close(after: Duration): Future[Unit]

final def close(): Future[Unit]

def closeAwaitably(f: ⇒ Future[Unit]): Future[Unit]

final def closeOnExit(closable: Closable): Unit

final def closeOnExitLast(closable: Closable): Unit

def configureAdminHttpServer(server: Server): Server

def configureLoggerFactories(): Unit

com.twitter.logging.Logging.configureLoggerFactories() removes all added JUL handlers and adds only handlers defined by com.twitter.logging.Logging.loggerFactories.

def debug(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def debug(message: ⇒ Any, cause: Throwable): Unit

def debug(marker: Marker, message: ⇒ Any): Unit

def debug(message: ⇒ Any): Unit

def debugFutureResult[T](msg: String)(func: ⇒ Future[T]): Future[T]

def debugResult[T](message: ⇒ String)(fn: ⇒ T): T

def defaultAdminPort: Int

def defaultAppend: Boolean

def defaultCloseGracePeriod: Duration

def defaultFormatter: Formatter

def defaultLogLevel: Level

def defaultOutput: String

def defaultRollPolicy: Policy

def defaultRotateCount: Int

def disableAdminHttpServer: Boolean

val dtabAddBaseFlag: Flag[Dtab]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def error(message: ⇒ Any, cause: Throwable): Unit

def error(marker: Marker, message: ⇒ Any): Unit

def error(message: ⇒ Any): Unit

def errorResult[T](message: ⇒ String)(fn: ⇒ T): T

def exitOnError(reason: String, details: ⇒ String): Unit

def exitOnError(reason: String): Unit

def exitOnError(throwable: Throwable): Unit

def failfastOnFlagsNotParsed: Boolean

def finalize(): Unit

val flag: app.Flags

final def getClass(): Class[_]

val group: String

def handle(clazz: Class[_ <: Handler]): Unit

Utility to run a com.twitter.inject.utils.Handler.

def handle[T <: Handler]()(implicit arg0: Manifest[T]): Unit

Utility to run a com.twitter.inject.utils.Handler.

def handlers: List[() ⇒ Handler]

def hashCode(): Int

def httpExternalPort: Option[Int]

def httpsExternalPort: Option[Int]

val inferClassNamesFlag: Flag[Boolean]

def info(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def info(message: ⇒ Any, cause: Throwable): Unit

def info(marker: Marker, message: ⇒ Any): Unit

def info(message: ⇒ Any): Unit

def infoResult[T](message: ⇒ String)(fn: ⇒ T): T

final def init(f: ⇒ Unit): Unit

def injector: Injector

def isDebugEnabled(marker: Marker): Boolean

def isDebugEnabled: Boolean

def isErrorEnabled(marker: Marker): Boolean

def isErrorEnabled: Boolean

def isInfoEnabled(marker: Marker): Boolean

def isInfoEnabled: Boolean

final def isInstanceOf[T0]: Boolean

def isReady(implicit permit: CanAwait): Boolean

def isTraceEnabled(marker: Marker): Boolean

def isTraceEnabled: Boolean

def isWarnEnabled(marker: Marker): Boolean

def isWarnEnabled: Boolean

def javaModules: Collection[Module]

def javaOverrideModules: Collection[Module]

val levelFlag: Flag[Level]

def libraryName: String

Name used for registration in the com.twitter.util.registry.Library

def linterRules: Seq[Rule]

def loadModules(): InstalledModules

def loadServiceBindings: Seq[Binding[_]]

final def logger: Logger

def loggerFactories: List[LoggerFactory]

final def loggerName: String

final def main(): Unit

final def main(args: Array[String]): Unit

def modules: Seq[Module]

val name: String

final def ne(arg0: AnyRef): Boolean

final def nonExitingMain(args: Array[String]): Unit

final def notify(): Unit

final def notifyAll(): Unit

final def onExit(f: ⇒ Unit): Unit

final def onExitLast(f: ⇒ Unit): Unit

val outputFlag: Flag[String]

def overrideModules: Seq[Module]

def parseArgs(args: Array[String]): Unit

def postInjectorStartup(): Unit

After creation of the Injector.

def postWarmup(): Unit

If you override this method to create and bind any external interface or to instantiate any awaitable it is expected that you add the Awaitable (or com.twitter.finagle.ListeningServer) to the list of Awaitables using the await[T <: Awaitable[_(awaitable: T): Unit function.

final def postmain(f: ⇒ Unit): Unit

def prebindWarmup(): Unit

final def premain(f: ⇒ Unit): Unit

def ready(timeout: Duration)(implicit permit: CanAwait): TwitterServer.this.type

def resolveFinagleClientsOnStartup: Boolean

Resolve all Finagle clients before warmup method called

def result(timeout: Duration)(implicit permit: CanAwait): Unit

val rollPolicyFlag: Flag[Policy]

val rotateCountFlag: Flag[Int]

def routes: Seq[Route]

final def run(): Unit

def setup(): Unit

Callback method which is executed specifically in the postInjectorStartup lifecycle phase of this server.

lazy val shutdownTimer: Timer

def start(): Unit

Callback method which is executed after the injector is created and all lifecycle methods have fully completed but before awaiting on any Awaitables.

def statsReceiver: StatsReceiver

def statsReceiverModule: Module

Default com.twitter.inject.TwitterModule for providing a com.twitter.finagle.stats.StatsReceiver.

final val suppressGracefulShutdownErrors: Boolean

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

def thriftPort: Option[Int]

def time[T](formatStr: String)(func: ⇒ T): T

def toString(): String

def trace(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def trace(message: ⇒ Any, cause: Throwable): Unit

def trace(marker: Marker, message: ⇒ Any): Unit

def trace(message: ⇒ Any): Unit

def traceResult[T](message: ⇒ String)(fn: ⇒ T): T

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warmup(): Unit

Callback method run before TwitterServer.postWarmup, used for performing warm up of this server.

def warmupComplete(): Unit

def warn(marker: Marker, message: ⇒ Any, cause: Throwable): Unit

def warn(message: ⇒ Any, cause: Throwable): Unit

def warn(marker: Marker, message: ⇒ Any): Unit

def warn(message: ⇒ Any): Unit

def warnResult[T](message: ⇒ String)(fn: ⇒ T): T

lazy val log: Logger