or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.mdserver-components.mdserver-management.mdwebsocket-support.md
tile.json

tessl/maven-com-typesafe-play--play-netty-server-2-10

Netty-based HTTP server implementation for the Play Framework providing high-performance, asynchronous HTTP processing with WebSocket support.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.typesafe.play/play-netty-server_2.10@2.4.x

To install, run

npx @tessl/cli install tessl/maven-com-typesafe-play--play-netty-server-2-10@2.4.0

index.mddocs/

Play Netty Server

Play Netty Server is a high-performance, asynchronous HTTP server implementation built on Netty 3.x that serves as the default server backend for Play Framework applications. It provides comprehensive HTTP/HTTPS request processing, WebSocket support, SSL/TLS termination, and seamless integration with Play's reactive architecture.

Package Information

  • Package Name: play-netty-server_2.10
  • Package Type: maven
  • Language: Scala
  • Installation: libraryDependencies += "com.typesafe.play" %% "play-netty-server" % "2.4.11"

Core Imports

import play.core.server.NettyServer
import play.core.server.NettyServerProvider
import play.core.server.NettyServerComponents

Basic Usage

import play.api.Application
import play.core.server.{NettyServer, ServerConfig}
import play.api.mvc.{RequestHeader, Handler}
import play.api.routing.Router

// Create server from Application
val server = NettyServer.fromApplication(application, ServerConfig())

// Create server from routes
val server = NettyServer.fromRouter() {
  case request @ GET -> Root / "hello" =>
    Action { Ok("Hello World") }
}

// Stop the server
server.stop()

Architecture

Play Netty Server is built around several key components:

  • NettyServer: Main server class handling HTTP/HTTPS connections and lifecycle management
  • Request Pipeline: Multi-stage processing pipeline with handlers for HTTP parsing, WebSocket upgrades, and request routing
  • Response Streaming: Efficient streaming of Play Results back to clients with support for chunked encoding and connection management
  • WebSocket Support: Full WebSocket protocol implementation with frame handling and flow control
  • SSL/TLS Integration: Built-in SSL/TLS support using Play's SSLEngine infrastructure

Capabilities

Server Creation and Management

Core server instantiation, configuration, and lifecycle management. Provides factory methods for creating servers from applications or route definitions.

object NettyServer {
  def fromApplication(
    application: Application, 
    config: ServerConfig = ServerConfig()
  ): NettyServer
  
  def fromRouter(config: ServerConfig = ServerConfig())(
    routes: PartialFunction[RequestHeader, Handler]
  ): NettyServer
  
  implicit val provider: NettyServerProvider
}

class NettyServer(
  config: ServerConfig,
  applicationProvider: ApplicationProvider,
  stopHook: () => Future[Unit]
) extends Server {
  def mode: Mode.Mode
  def stop(): Unit
  def httpPort: Option[Int]
  def httpsPort: Option[Int]
  def mainAddress: java.net.InetSocketAddress
}

Server Management

Server Components

Cake pattern components for building and configuring Netty servers with dependency injection support.

trait NettyServerComponents {
  lazy val serverConfig: ServerConfig
  lazy val server: NettyServer
  lazy val environment: Environment
  lazy val configuration: Configuration
  def application: Application
  def serverStopHook: () => Future[Unit]
}

class NettyServerProvider extends ServerProvider {
  def createServer(context: ServerProvider.Context): NettyServer
}

Server Components

WebSocket Support

Full WebSocket protocol implementation with handshake handling, frame processing, and flow control for real-time communication.

// Internal WebSocket handling (used by Play framework)
trait WebSocketHandler {
  def websocketHandshake[A](
    ctx: ChannelHandlerContext,
    req: HttpRequest,
    e: MessageEvent,
    bufferLimit: Long
  )(frameFormatter: FrameFormatter[A]): Enumerator[A]
  
  def websocketable(req: HttpRequest): WebSocketable
}

WebSocket Support

Types

// Core server configuration
case class ServerConfig(
  rootDir: java.io.File,
  port: Option[Int],
  sslPort: Option[Int], 
  address: String,
  mode: Mode.Mode,
  properties: java.util.Properties,
  configuration: Configuration
)

object ServerConfig {
  def apply(
    classLoader: ClassLoader = ServerConfig.getClass.getClassLoader,
    rootDir: java.io.File = new java.io.File("."),
    port: Option[Int] = Some(9000),
    sslPort: Option[Int] = None,
    address: String = "0.0.0.0",
    mode: Mode.Mode = Mode.Prod,
    properties: java.util.Properties = System.getProperties
  ): ServerConfig
}

// Server provider context
case class ServerProvider.Context(
  config: ServerConfig,
  appProvider: ApplicationProvider,
  actorSystem: akka.actor.ActorSystem,
  stopHook: () => Future[Unit]
)

// Application provider for lazy loading
trait ApplicationProvider {
  def get: scala.util.Try[Application]
  def current: Option[Application]
  def handleWebCommand(requestHeader: RequestHeader): Option[Result]
}

object ApplicationProvider {
  def apply(application: Application): ApplicationProvider
}

// Base server trait
trait Server {
  def mode: Mode.Mode
  def applicationProvider: ApplicationProvider
  def stop(): Unit
  def httpPort: Option[Int]
  def httpsPort: Option[Int]
  def mainAddress: java.net.InetSocketAddress
  def getHandlerFor(request: RequestHeader): Either[Future[Result], (RequestHeader, Handler, Application)]
}

// Play modes
object Mode {
  sealed trait Mode
  case object Dev extends Mode
  case object Test extends Mode  
  case object Prod extends Mode
}