DefaultWebSocketServerSession

interface DefaultWebSocketServerSession : 
    DefaultWebSocketSession,
    WebSocketServerSession

Represents a server-side web socket session with all default implementations

See Also

DefaultWebSocketSession

Inherited Properties

call

abstract val call: ApplicationCall

Associated received call that originating this session

closeReason

abstract val closeReason: Deferred<CloseReason?>

A close reason for this session. It could be null if a session is terminated with no close reason (for example due to connection failure).

pingIntervalMillis

abstract var pingIntervalMillis: Long

Ping interval or -1L to disable pinger. Please note that pongs will be handled despite of this setting.

timeoutMillis

abstract var timeoutMillis: Long

A timeout to wait for pong reply to ping otherwise the session will be terminated immediately. It doesn’t have any effect if pingIntervalMillis is -1 (pinger is disabled).

Extension Properties

application

An application that started this web socket session

pingInterval

var DefaultWebSocketServerSession.pingInterval: Duration?

Ping interval or null to disable pinger. Please note that pongs will be handled despite of this setting.

timeout

var DefaultWebSocketServerSession.timeout: Duration

A timeout to wait for pong reply to ping otherwise the session will be terminated immediately. It doesn’t have any effect if pingInterval is null (pinger is disabled).

Extension Functions

close

suspend fun WebSocketSession.close(
    reason: CloseReason = CloseReason(CloseReason.Codes.NORMAL, "")
): Unit

Send a close frame with the specified reason. May suspend if outgoing channel is full. The specified reason could be ignored if there was already close frame sent (for example in reply to a peer close frame). It also may do nothing when a session or an outgoing channel is already closed due to any reason.

suspend fun WebSocketSession.close(cause: Throwable?): Unit

Closes with reason depending on cause or normally if cause is null. This is going to be removed. Close with a particular reason or terminate instead.

closeExceptionally

suspend fun WebSocketSession.closeExceptionally(
    cause: Throwable
): Unit

Closes session with normal or error close reason, depending on whether cause is cancellation or not.

decodeChunked

fun CoroutineScope.decodeChunked(
    input: ByteReadChannel
): DecoderJob
fun CoroutineScope.decodeChunked(
    input: ByteReadChannel,
    contentLength: Long
): DecoderJob

Start a chunked stream decoder coroutine

embeddedServer

fun <TEngine : ApplicationEngine, TConfiguration : Configuration> CoroutineScope.embeddedServer(
    factory: ApplicationEngineFactory<TEngine, TConfiguration>,
    port: Int = 80,
    host: String = "0.0.0.0",
    watchPaths: List<String> = emptyList(),
    parentCoroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    configure: TConfiguration.() -> Unit = {},
    module: Application.() -> Unit
): TEngine

Creates an embedded server with the given factory, listening on host:port

httpServer

fun CoroutineScope.httpServer(
    settings: HttpServerSettings,
    handler: HttpRequestHandler
): HttpServer

Start an http server with settings invoking handler for every request

httpServer

fun CoroutineScope.httpServer(
    settings: HttpServerSettings,
    handler: suspend CoroutineScope.(request: Request, input: ByteReadChannel, output: ByteWriteChannel, upgraded: CompletableDeferred<Boolean>?) -> Unit
): HttpServer

Start an http server with settings invoking handler for every request

mapEngineExceptions

fun CoroutineScope.mapEngineExceptions(
    input: ByteReadChannel,
    request: HttpRequestData
): ByteReadChannel

Returns ByteReadChannel with ByteChannel.close handler that returns SocketTimeoutException instead of SocketTimeoutException.

fun CoroutineScope.mapEngineExceptions(
    output: ByteWriteChannel,
    request: HttpRequestData
): ByteWriteChannel

Returns ByteWriteChannel with ByteChannel.close handler that returns SocketTimeoutException instead of SocketTimeoutException.

parseMultipart

fun CoroutineScope.parseMultipart(
    input: ByteReadChannel,
    headers: HttpHeadersMap
): ReceiveChannel<MultipartEvent>
fun CoroutineScope.parseMultipart(
    input: ByteReadChannel,
    contentType: CharSequence,
    contentLength: Long?
): ReceiveChannel<MultipartEvent>
fun CoroutineScope.parseMultipart(
    boundaryPrefixed: ByteBuffer,
    input: ByteReadChannel,
    totalLength: Long?
): ReceiveChannel<MultipartEvent>

Starts a multipart parser coroutine producing multipart events

pinger

fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    period: Duration,
    timeout: Duration,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified period to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeout and sending timeout close frame

fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    periodMillis: Long,
    timeoutMillis: Long,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified periodMillis to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeoutMillis and sending timeout close frame

pinger

fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    period: <ERROR CLASS>,
    timeout: <ERROR CLASS>,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified period to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeout and sending timeout close frame

ponger

fun CoroutineScope.ponger(
    outgoing: SendChannel<Pong>,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Ping>

Launch a ponger actor job on the CoroutineScope sending pongs to outgoing channel. It is acting for every client’s ping frame and replying with corresponding pong

reader

fun CoroutineScope.reader(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    channel: ByteChannel,
    block: suspend ReaderScope.() -> Unit
): ReaderJob
fun CoroutineScope.reader(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    autoFlush: Boolean = false,
    block: suspend ReaderScope.() -> Unit
): ReaderJob

run

suspend fun DefaultWebSocketSession.run(
    handler: suspend DefaultWebSocketSession.() -> Unit
): Unit

send

suspend fun WebSocketSession.send(content: String): Unit

Enqueues a text frame for sending with the specified content.

suspend fun WebSocketSession.send(content: ByteArray): Unit

Enqueues a final binary frame for sending with the specified content.

startConnectionPipeline

fun CoroutineScope.startConnectionPipeline(
    input: ByteReadChannel,
    output: ByteWriteChannel,
    timeout: WeakTimeoutQueue,
    handler: suspend CoroutineScope.(request: Request, input: ByteReadChannel, output: ByteWriteChannel, upgraded: CompletableDeferred<Boolean>?) -> Unit
): Job

Start connection HTTP pipeline invoking handler for every request. Note that handler could be invoked multiple times concurrently due to HTTP pipeline nature

startServerConnectionPipeline

fun CoroutineScope.startServerConnectionPipeline(
    connection: ServerIncomingConnection,
    timeout: WeakTimeoutQueue,
    handler: HttpRequestHandler
): Job

Start connection HTTP pipeline invoking handler for every request. Note that handler could be invoked multiple times concurrently due to HTTP pipeline nature

writeMultipleRanges

fun CoroutineScope.writeMultipleRanges(
    channelProducer: (LongRange) -> ByteReadChannel,
    ranges: List<LongRange>,
    fullLength: Long?,
    boundary: String,
    contentType: String
): ByteReadChannel

Start multirange response writer coroutine

writer

fun CoroutineScope.writer(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    channel: ByteChannel,
    block: suspend WriterScope.() -> Unit
): WriterJob
fun CoroutineScope.writer(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    autoFlush: Boolean = false,
    block: suspend WriterScope.() -> Unit
): WriterJob