io.ktor.network.selector / ActorSelectorManager

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