ActorSelectorManager

class ActorSelectorManager : 
    SelectorManagerSupport,
    Closeable,
    CoroutineScope

Default CIO selector manager implementation

Constructors

<init>

ActorSelectorManager(dispatcher: <ERROR CLASS>)

Default CIO selector manager implementation

Properties

coroutineContext

val coroutineContext: <ERROR CLASS>

Inherited Properties

cancelled

var cancelled: Int

Number of cancelled keys

pending

var pending: Int

Number of pending selectables

provider

val provider: SelectorProvider

NIO selector provider

Functions

close

fun close(): Unit

Close selector manager and release all resources

notifyClosed

fun notifyClosed(s: Selectable): Unit

Notifies the selector that selectable has been closed.

publishInterest

fun publishInterest(selectable: Selectable): Unit

Publish current selectable interest

Inherited Functions

applyInterest

fun applyInterest(selector: Selector, s: Selectable): Unit

Applies selectable’s current interest (should be invoked in selection thread)

cancelAllSuspensions

fun cancelAllSuspensions(
    attachment: Selectable,
    t: Throwable
): Unit

Cancel all selectable’s suspensions with the specified exception

fun cancelAllSuspensions(
    selector: Selector,
    t: Throwable?
): Unit

Cancel all suspensions with the specified exception, reset all interests

handleSelectedKey

fun handleSelectedKey(key: SelectionKey): Unit

Handles particular selected key

handleSelectedKeys

fun handleSelectedKeys(
    selectedKeys: MutableSet<SelectionKey>,
    keys: Set<SelectionKey>
): Unit

Handle selected keys clearing selectedKeys set

notifyClosedImpl

fun notifyClosedImpl(
    selector: Selector,
    key: SelectionKey,
    attachment: Selectable
): Unit

Notify selectable’s closure

select

suspend fun select(
    selectable: Selectable,
    interest: SelectInterest
): Unit

Suspends until interest is selected for selectable May cause manager to allocate and run selector instance if not yet created.

Extension Functions

buildOrClose

fun <C : Closeable, R> SelectorManager.buildOrClose(
    create: SelectorProvider.() -> C,
    setup: C.() -> R
): R

Creates a NIO entity via create and calls setup on it. If any exception happens then the entity will be closed and an exception will be propagated.

decodeChunked

fun CoroutineScope.decodeChunked(
    input: ByteReadChannel
): 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

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

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

startConnectionPipeline

fun CoroutineScope.startConnectionPipeline(
    input: ByteReadChannel,
    output: ByteWriteChannel,
    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