RefreshTokenFeature is not working after kotlin 1.4 update about moko-network HOT 5 CLOSED

Gael Ribes:fr:  1 hour ago
I created a Ktor Client Feature for that.
override fun install(feature: AuthFeature, scope: HttpClient) {
    scope.requestPipeline.intercept(HttpRequestPipeline.State) {
        if (context.usesAuthentication) {
            val token = feature.authTokenService.getToken() ?: return@intercept
            context.headers[HttpHeaders.Authorization] = "Bearer $token"
        }
    }
    val circuitBreaker = AttributeKey<Unit>("my-auth-request")
    scope.feature(HttpSend)!!.intercept { origin, context ->
        if (origin.response.status != HttpStatusCode.Unauthorized) return@intercept origin
        if (origin.request.attributes.contains(circuitBreaker)) return@intercept origin
        if (!feature.authTokenService.refreshToken()) return@intercept origin
        val token = feature.authTokenService.getToken() ?: return@intercept origin
        val request = HttpRequestBuilder()
        request.takeFromWithExecutionContext(context)
        request.headers[HttpHeaders.Authorization] = "Bearer $token"
        request.attributes.put(circuitBreaker, Unit)
        return@intercept execute(request)
    }
}

class TokenFeature(
    private val tokenHeaderName: String,
    private val tokenProvider: () -> String?,
    private val tokenUpdater: suspend () -> Boolean,
    private val sameTokenChecker: (HttpRequest) -> Boolean
) {

    class Config {
        var tokenHeaderName: String? = null
        var tokenProvider: (() -> String?)? = null
        var tokenUpdater: (suspend () -> Boolean)? = null
        var sameTokenChecker: ((HttpRequest) -> Boolean)? = null

        fun build() = TokenFeature(
            tokenHeaderName ?: throw IllegalArgumentException("headerName should be passed"),
            tokenProvider ?: throw IllegalArgumentException("tokenProvider should be passed"),
            tokenUpdater ?: throw IllegalArgumentException("tokenUpdater should be passed"),
            sameTokenChecker ?: throw IllegalArgumentException("sameTokenChecker should be passed")
        )
    }

    companion object Feature : HttpClientFeature<Config, TokenFeature> {

        private val refreshTokenMutex = Mutex()

        override val key = AttributeKey<TokenFeature>("TokenFeature")

        override fun prepare(block: Config.() -> Unit) = Config().apply(block).build()

        @OptIn(InternalAPI::class)
        override fun install(feature: TokenFeature, scope: HttpClient) {
            scope.requestPipeline.intercept(HttpRequestPipeline.State) {
                feature.tokenProvider.invoke().let { token ->
                    context.headers.remove(feature.tokenHeaderName)
                    context.header(feature.tokenHeaderName, token)
                }
            }
            val circuitBreaker = AttributeKey<Unit>("TokenFeature_circuitBreaker")
            scope.feature(HttpSend)!!.intercept { origin, context ->
                // If there is no token error, don't do anything
                if (origin.response.status != HttpStatusCode.Unauthorized) return@intercept origin
                // If this interceptor has already been called, don't do anything
                if (origin.request.attributes.contains(circuitBreaker)) return@intercept origin

                // Lock here, so other requests will wait until the token is updated
                refreshTokenMutex.lock()

                // If the token of the request is the same, then the token
                // hasn't been updated yet and we should update it
                if (feature.sameTokenChecker.invoke(origin.request)) {
                    val refreshSuccess = feature.tokenUpdater.invoke()
                    // If token refresh failed, then just let the token error occur
                    if (!refreshSuccess) {
                        refreshTokenMutex.unlock()
                        return@intercept origin
                    }
                }

                val token = feature.tokenProvider.invoke()
                // If the token was removed, then just let the token error occur
                if (token == null) {
                    refreshTokenMutex.unlock()
                    return@intercept origin
                }

                // Execute the same request with a new token
                val request = HttpRequestBuilder()
                request.takeFrom(context)
                request.headers[feature.tokenHeaderName] = token
                request.attributes.put(circuitBreaker, Unit)

                refreshTokenMutex.unlock()

                return@intercept execute(request)
            }
        }
    }
}