ktor-utils/io.ktor.util.cio

Package-level declarations

Types

open class ChannelIOException(message: String, exception: Throwable) : IOException

An exception thrown when an IO error occurred during reading or writing to/from the underlying channel. The typical error is "connection reset" and so on.

ChannelReadException

class ChannelReadException(message: String = "Cannot read from a channel", exception: Throwable) : ChannelIOException

An exception that is thrown when an IO error occurred during reading from the request channel. Usually it happens when a remote client closed the connection.

ChannelWriteException

class ChannelWriteException(message: String = "Cannot write to a channel", exception: Throwable) : ChannelIOException

An exception that is thrown when an IO error occurred during writing to the destination channel. Usually it happens when a remote client closed the connection.

Properties

KtorDefaultPool

val KtorDefaultPool: ObjectPool<ByteBuffer>

The default ktor byte buffer pool

Functions

bufferedWriter

fun ByteWriteChannel.bufferedWriter(charset: Charset = Charsets.UTF_8): BufferedWriter

Open a buffered writer to the channel

pass

inline suspend fun ByteReadChannel.pass(buffer: ByteBuffer, block: (ByteBuffer) -> Unit)

Read data chunks from ByteReadChannel using buffer

readChannel

fun File.readChannel(start: Long = 0, endInclusive: Long = -1, coroutineContext: CoroutineContext = Dispatchers.IO): ByteReadChannel

Launch a coroutine to open a read channel for a file and fill it. Please note that file reading is blocking so if you are starting it on Dispatchers.Unconfined it may block your async code and freeze the whole application when runs on a pool that is not intended for blocking operations. This is why coroutineContext should have Dispatchers.IO or a coroutine dispatcher that is properly configured for blocking IO.

fun Path.readChannel(start: Long = 0, endInclusive: Long = -1, coroutineContext: CoroutineContext = Dispatchers.IO): ByteReadChannel

Launches a coroutine to open a read channel for a file and fill it. Please note that file reading is blocking so if you are starting it on Dispatchers.Unconfined it may block your async code and freeze the whole application when runs on a pool that is not intended for blocking operations. This is why coroutineContext should have Dispatchers.IO or a coroutine dispatcher that is properly configured for blocking IO.

toByteArray

suspend fun ByteReadChannel.toByteArray(limit: Int = Int.MAX_VALUE): ByteArray

Convert ByteReadChannel to ByteArray

toByteReadChannel

fun InputStream.toByteReadChannel(pool: ObjectPool<ByteBuffer> = KtorDefaultPool, context: CoroutineContext = Dispatchers.Unconfined, parent: Job = Job()): ByteReadChannel

Open a channel and launch a coroutine to copy bytes from the input stream to the channel. Please note that it may block your async code when started on Dispatchers.Unconfined since InputStream is blocking on it's nature

use

inline fun ByteWriteChannel.use(block: ByteWriteChannel.() -> Unit)

Executes block on ByteWriteChannel and close it down correctly whether an exception

writeChannel

fun File.writeChannel(coroutineContext: CoroutineContext = Dispatchers.IO): ByteWriteChannel

Open a write channel for the file and launch a coroutine to read from it. Please note that file writing is blocking so if you are starting it on Dispatchers.Unconfined it may block your async code and freeze the whole application when runs on a pool that is not intended for blocking operations. This is why coroutineContext should have Dispatchers.IO or a coroutine dispatcher that is properly configured for blocking IO.

writer

fun ByteWriteChannel.writer(charset: Charset = Charsets.UTF_8): Writer

Open a writer to the channel