ktor: kotlin.native.concurrent.InvalidMutabilityException: mutation attempt of frozen kotlinx.coroutines.StandaloneCoroutine@28a82d8

This issue happens on version 1.4.0 while on 1.3.2-1.4.0-rc everything works fine.

Having a very similar issue on 1.4.0 when doing a simple get request on ios: Uncaught Kotlin exception: kotlin.native.concurrent.InvalidMutabilityException: mutation attempt of frozen kotlinx.coroutines.ChildHandleNode@31dca08 reverting back to 1.3.2-1.4.0-rc works like a charm.

same error with me.

@joaquim-verges I solve it.

kotlin_version=1.4.0
kotlinx_coroutines_version=1.3.9-native-mt
kotlinx_ktor_version=1.4.0
kotlinx_serialization_version=1.0.0-RC

// ...
sourceSets {
        val commonMain by sourceSets.getting {
            dependencies {
                api("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinx_coroutines_version")
                api("org.jetbrains.kotlinx:kotlinx-serialization-core:$kotlinx_serialization_version")
                api("io.ktor:ktor-client-core:$kotlinx_ktor_version")
                api("io.ktor:ktor-client-json:$kotlinx_ktor_version")
                api("io.ktor:ktor-client-serialization:$kotlinx_ktor_version")
            }
        }

        val iosMain by sourceSets.getting {
            dependencies {
                implementation("io.ktor:ktor-client-ios:$kotlinx_ktor_version")
            }
        }
        val iosX64Main by sourceSets.getting {
            dependencies {
            }
        }
        val iosArm64Main by sourceSets.getting {
            dependencies {
            }
        }
        val androidMain by sourceSets.getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlinx_coroutines_version")
                implementation("io.ktor:ktor-client-android:$kotlinx_ktor_version")
            }
        }
    }

interface IUserApi {
    suspend fun users(): List<User>
}

expect val httpClientEngine: HttpClientEngine

class UserApi : IUserApi {

    private val baseUrl = "https://jsonplaceholder.typicode.com"
    private val client = HttpClient(httpClientEngine) {
        install(JsonFeature) {
            serializer = KotlinxSerializer(json = kotlinx.serialization.json.Json {
                isLenient = false
                ignoreUnknownKeys = true
                allowSpecialFloatingPointValues = true
                useArrayPolymorphism = false
            })
        }
    }

    override suspend fun users(): List<User> {
        return client.get {
            setupCall(Endpoint.USERS)
        }
    }

    private fun HttpRequestBuilder.setupCall(endpoint: Endpoint) {
        url {
            takeFrom(urlString = baseUrl)
            encodedPath += endpoint.path
        }
    }
}

import io.ktor.client.engine.*
import io.ktor.client.engine.ios.*

actual val httpClientEngine: HttpClientEngine
    get() = Ios.create()

Worked for me with version 1.3.9-native-mt-2

Fixed with 1.3.9-native-mt-2

Try creating a new HttpClient every time you use it instead of retaining it in an instance variable. Also disable logging (remove the logging config from the client config).

I got everything working on my side with kotlin 1.4.10, ktor 1.4.0, coroutines 1.3.9-mt-2 and kotlinx.serialization 1.0.0-RC. It even works in a background thread (Dispatchers.DEFAULT). You have to take care though to create a new http client in the background thread for every call and to ensure you don’t reference other classes there that are accessed from the main thread.

See the following sample code:

    private suspend fun <T> withHttpClient(perform: suspend HttpClient.() -> T): T {
        // Run the following in a background thread, the HttpClient itself has to be constructed in the background thread as well.
        return withContext(Dispatchers.Default) {
            // Specify the HttpClient configuration,
            // be sure to not capture any global references because they will be frozen otherwise.
            val configuration: HttpClientConfig<*>.() -> Unit = ... 
            val client = HttpClient(block = configuration)
            try {
                perform(client)
            } finally {
                client.close()
            }
        }
    }

    private fun <T: Any>deserialize(type: KClass<T>, bytes: ByteArray): T {
        // Implement any deserialization logic or just use kotlinx.serialization
    }

    /**
     * Sample HTTP get, result will be parsed in the background, but returned in the main thread
     */
    suspend fun <T : Any> get(
        path: String,
        responseType: KClass<T>,
        parameters: Map<String, Any>
    ): T {
        // This happens in the main thread
        return withHttpClient(accessToken) {
            // This happens all in a background thread
            get<ByteArray>(path = path) {
                for ((key, value) in parameters) {
                    parameter(key, value)
                }
            }.let {
                deserialize(responseType, it)
            }
        }
    }

I’m also facing the same issue on 1.4.0 and I thought my code was the issue or I misunderstood the variable freezing functionality. But as you all pointed out it is an issue with 1.4.0.

@e5l I understand that you have a huge load of work and that we all go to you when there is an issue especially with Ktor but we would very much appreciate any kind of update on this issue. If there is a workaround or should we revert back to 1.4.0-rc or if the issue is being worked on currently and expected to be fixed in the next version. Any kind of update would be very much appreciated.