agcom / knio2

Kotlinx coroutines extensions for Java NIO.2

KNIO2

Just some Kotlinx coroutines extensions for java.nio.channels.Asynchronous* classes.

Setup

Published to the Maven Central repository.

Gradle snippet,

repositories {
    mavenCentral()
}

dependencies {
    implementation "io.github.agcom:knio2:0.4.1"
}

Components

• Suspending extension functions for following classes,

  • AsynchronousByteChannel
  • AsynchronousSocketChannel
  • AsynchronousFileChannel
  • AsynchronousServerSocketChannel

  The functions are named after their original name plus await suffix.

    import io.github.agcom.knio2.*
    import java.nio.ByteBuffer
    import java.nio.channels.AsynchronousSocketChannel
    
    suspend fun main() {
        val socket: AsynchronousSocketChannel = TODO().apply {
            connectAwait(TODO()) // connectAwait
        }
    
        ByteBuffer.allocate(TODO()).let {
            socket.readAwait(it) // readAwait
        }
    
        socket.writeAwait(Charsets.US_ASCII.encode("Hello world")) // writeAwait
    }

Contribution

I add what I need. Make sure you do it too 😃.

Status

If you only want Kotlinx coroutines IO, prefer its native libraries instead of Java ports. You can find them on Awesome Kotlin.

This is a temporary project and may deprecate in favor of better asynchronous IO solutions with Kotlinx coroutines. For example, the Kotlinx IO, which is kinda in development now.

knio2's Issues

Cancellable or not

Asynchronous channels provide no guarantee nor function to cancel calls. Should this behavior be reflected in coroutines (suspendCancellableCoroutine or cancellableCoroutine)?

Add to Awesome Kotlin

https://github.com/KotlinBy/awesome-kotlin

AsynchronousServerSocketChannel suspending extension functions

Publish to JCenter

Remove Bintray latest version badge

AsynchronousFileChannel suspending extension functions

Automate publish

Using https://github.com/gradle-nexus/publish-plugin.

Integration with `ktor-io` module

ktor-io: https://github.com/ktorio/ktor/tree/main/ktor-io

Migrate to the central repository

Read version string from Gradle properties rather than being hard coded

This would let CI/CD easily put the tag version into the artifact version when publishing.

Use suspendCancellableCoroutine anyway

To avoid blocking the execution in case of cancellation (although the underlying IO won't cancel).

Also, avoids this boilerplate 👇 to achieve the above goal ☝️.

fun main() {
    runBlocking {
        cancel()
        async { // Launch a new coroutine
            sus()
        }.await()
    }
}

suspend fun sus() {
    suspendCoroutine<Unit> { /*Suspend forever*/ }
}

Update Gradle to 7.2 & Kotlin to 1.5.21 & Kotlinx coroutines to 1.5.1