Fixed flaky tests, optimized internal structure

Author: Mr3zee

gradle-conventions/src/main/kotlin/util/targets/configure.kt

@@ -7,7 +7,6 @@ package util.targets
 import io.gitlab.arturbosch.detekt.extensions.DetektExtension
 import org.gradle.api.Action
 import org.gradle.api.Project
-import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.kotlin.dsl.the
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
@@ -31,7 +30,9 @@ private fun KotlinMultiplatformExtension.configureTargets(config: KmpConfig): Li
     if (config.js) {
         js(IR) {
             nodejs()
-            browser()
+            if (!config.kotlinMasterBuild) {
+                browser()
+            }
 
             binaries.library()
         }.also { targets.add(it) }

gradle-conventions/src/main/kotlin/util/targets/wasm.kt

@@ -24,7 +24,10 @@ fun KmpConfig.configureWasm() {
             wasmJs {
                 configureJsAndWasmJsTasks()
 
-                browser()
+                if (!kotlinMasterBuild) {
+                    browser()
+                }
+
                 nodejs()
                 if (wasmJsD8) {
                     // this platform needs some care KRPC-210

krpc/krpc-client/src/commonMain/kotlin/kotlinx/rpc/krpc/client/KrpcClient.kt

@@ -9,9 +9,6 @@ import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.InternalCoroutinesApi
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.cancelAndJoin
@@ -79,7 +76,6 @@ public abstract class InitializedKrpcClient(
  * serializing data, tracking streams, processing exceptions, and other protocol responsibilities.
  * Leaves out the delivery of encoded messages to the specific implementations with [KrpcTransport].
  */
-@OptIn(InternalCoroutinesApi::class)
 public abstract class KrpcClient : RpcClient, KrpcEndpoint {
     /**
      * Called once to provide [KrpcTransport] for this client.
@@ -154,21 +150,22 @@ public abstract class KrpcClient : RpcClient, KrpcEndpoint {
 
         val context = SupervisorJob(transport.coroutineContext.job)
 
-        context.job.invokeOnCompletion(onCancelling = true) {
-            if (clientCancelled) {
-                return@invokeOnCompletion
-            }
-
-            clientCancelled = true
+        context.job.invokeOnCompletion {
+            try {
+                if (!clientCancelled && !clientCancelledByServer) {
+                    sendCancellation(CancellationType.ENDPOINT, null, null, closeTransportAfterSending = true)
+                }
 
-            if (!clientCancelledByServer) {
-                sendCancellation(CancellationType.ENDPOINT, null, null, closeTransportAfterSending = true)
-            }
+                clientCancelled = true
+            } catch (_ : Exception) {
+                // ignore, we are already cancelled
+            } finally {
+                requestChannels.values.forEach {
+                    val cause = CancellationException("Client cancelled")
+                    it.close(cause)
+                    it.cancel(cause)
+                }
 
-            @OptIn(DelicateCoroutinesApi::class)
-            @Suppress("detekt.GlobalCoroutineUsage")
-            GlobalScope.launch(CoroutineName("client-request-channels-closing")) {
-                requestChannels.values.forEach { it.close(CancellationException("Client cancelled")) }
                 requestChannels.clear()
             }
         }
@@ -333,6 +330,7 @@ public abstract class KrpcClient : RpcClient, KrpcEndpoint {
                 throw e
             } finally {
                 channel.close()
+                channel.cancel()
                 requestChannels.remove(callId)
                 connector.unsubscribeFromMessages(call.descriptor.fqName, callId)
             }
@@ -484,7 +482,7 @@ public abstract class KrpcClient : RpcClient, KrpcEndpoint {
         } catch (e: CancellationException) {
             internalScope.ensureActive()
 
-            failure = ManualCancellationException(e)
+            failure = e
 
             // stop the flow and its coroutine, other flows are not affected
             throw e

krpc/krpc-core/src/commonMain/kotlin/kotlinx/rpc/krpc/internal/ExceptionUtils.kt

@@ -13,7 +13,11 @@ public fun serializeException(cause: Throwable): SerializedException {
     val message = cause.message ?: "Unknown exception"
     val stacktrace = cause.stackElements()
     val serializedCause = cause.cause?.let { serializeException(it) }
-    val className = cause::class.rpcInternalTypeName ?: ""
+    val className = if (cause is CancellationException || cause is kotlin.coroutines.cancellation.CancellationException) {
+        CancellationException::class.rpcInternalTypeName ?: "kotlinx.coroutines.CancellationException"
+    } else {
+        cause::class.rpcInternalTypeName ?: ""
+    }
 
     return SerializedException(cause.toString(), message, stacktrace, serializedCause, className)
 }
@@ -22,16 +26,15 @@ internal expect fun Throwable.stackElements(): List<StackElement>
 
 internal expect fun SerializedException.deserializeUnsafe(): Throwable
 
-internal fun SerializedException.nonJvmManualCancellationExceptionDeserialize(): ManualCancellationException? {
-    if (className == ManualCancellationException::class.rpcInternalTypeName) {
-        val cancellation = cause?.deserializeUnsafe()
-            ?: error("ManualCancellationException must have a cause")
+internal fun SerializedException.cancellationExceptionDeserialize(): CancellationException? {
+    if (className == CancellationException::class.rpcInternalTypeName
+        || className == kotlin.coroutines.cancellation.CancellationException::class.rpcInternalTypeName
+    ) {
+        val cause = this@cancellationExceptionDeserialize.cause?.deserializeUnsafe()
 
-        return ManualCancellationException(
-            CancellationException(
-                message = cancellation.message,
-                cause = cancellation.cause,
-            )
+        return CancellationException(
+            message = message,
+            cause = cause,
         )
     }
 
@@ -44,29 +47,19 @@ public fun SerializedException.deserialize(): Throwable {
         deserializeUnsafe()
     }
 
-    val result = if (cause.isFailure) {
+    return if (cause.isFailure) {
         cause.exceptionOrNull()!!
     } else {
-        val ex = cause.getOrNull()!!
-        if (ex is ManualCancellationException) {
-            ex.cause
-        } else {
-            ex
-        }
+        cause.getOrNull()!!
     }
-
-    return result
 }
 
-@InternalRpcApi
-public class ManualCancellationException(override val cause: CancellationException): RuntimeException()
-
 internal expect class DeserializedException(
     toStringMessage: String,
     message: String,
     stacktrace: List<StackElement>,
     cause: SerializedException?,
-    className: String
+    className: String,
 ) : Throwable {
     override val message: String
 }

krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcSendHandlerTest.kt

@@ -111,7 +111,7 @@ internal abstract class KrpcSendHandlerBaseTest {
     }
 
     protected fun runTest(
-        timeout: Duration = 10.seconds,
+        timeout: Duration = 30.seconds,
         body: suspend TestScope.(Channel<KrpcTransportMessage>, KrpcSendHandler) -> Unit,
     ) = runTestWithCoroutinesProbes(timeout = timeout) {
         val channel = Channel<KrpcTransportMessage>(

krpc/krpc-core/src/jsMain/kotlin/kotlinx/rpc/krpc/internal/ExceptionUtils.js.kt

@@ -23,6 +23,6 @@ internal actual class DeserializedException actual constructor(
 internal actual fun Throwable.stackElements(): List<StackElement> = emptyList()
 
 internal actual fun SerializedException.deserializeUnsafe(): Throwable {
-    return nonJvmManualCancellationExceptionDeserialize()
+    return cancellationExceptionDeserialize()
         ?: DeserializedException(toStringMessage, message, stacktrace, cause, className)
 }

krpc/krpc-core/src/jvmMain/kotlin/kotlinx/rpc/krpc/internal/ExceptionUtils.jvm.kt

@@ -37,6 +37,11 @@ internal actual fun Throwable.stackElements(): List<StackElement> = stackTrace.m
 }
 
 internal actual fun SerializedException.deserializeUnsafe(): Throwable {
+    val cancellationException = cancellationExceptionDeserialize()
+    if (cancellationException != null) {
+        return cancellationException
+    }
+
     try {
         val clazz = Class.forName(className)
         val fieldsCount = clazz.fieldsCountOrDefault(throwableFields)

krpc/krpc-core/src/nativeMain/kotlin/kotlinx/rpc/krpc/internal/ExceptionUtils.native.kt

@@ -22,6 +22,6 @@ internal actual class DeserializedException actual constructor(
 internal actual fun Throwable.stackElements(): List<StackElement> = emptyList()
 
 internal actual fun SerializedException.deserializeUnsafe(): Throwable {
-    return nonJvmManualCancellationExceptionDeserialize()
+    return cancellationExceptionDeserialize()
         ?: DeserializedException(toStringMessage, message, stacktrace, cause, className)
 }

krpc/krpc-core/src/wasmJsMain/kotlin/kotlinx/rpc/krpc/internal/ExceptionUtils.wasm.kt

@@ -23,6 +23,6 @@ internal actual class DeserializedException actual constructor(
 internal actual fun Throwable.stackElements(): List<StackElement> = emptyList()
 
 internal actual fun SerializedException.deserializeUnsafe(): Throwable {
-    return nonJvmManualCancellationExceptionDeserialize()
+    return cancellationExceptionDeserialize()
         ?: DeserializedException(toStringMessage, message, stacktrace, cause, className)
 }

krpc/krpc-core/src/wasmWasiMain/kotlin/kotlinx/rpc/krpc/internal/ExceptionUtils.wasmWasi.kt

@@ -20,6 +20,6 @@ internal actual class DeserializedException actual constructor(
 internal actual fun Throwable.stackElements(): List<StackElement> = emptyList()
 
 internal actual fun SerializedException.deserializeUnsafe(): Throwable {
-    return nonJvmManualCancellationExceptionDeserialize()
+    return cancellationExceptionDeserialize()
         ?: DeserializedException(toStringMessage, message, stacktrace, cause, className)
 }