Cancel a job if timeout exceed

[CristianCardosoA]

I found a little problem, if the timeout is exceeded, the job is continue working until it finished.
The expected behavior that I supposed is that the job is going to be cancel if the time is exceeded.

waitForTheServerToSetUp() is a suspend function

This is the code

      val result = withTimeoutOrNull(mTimeoutDownloadDefault){

            job = launch(exceptionLogger) {

                      try {

                            download()

                      } catch (e : Exception) {

                             mError = true
                      }
            }

            job.join()
   }

   if(result == null){
      mError = true
   }


    private suspend fun download() {

    val job = launch {

        APIClient.getLifeEventTypes(this@DownloadManager).await()
    }
    job.join()
}

[qwwdfsad]

Hi!
I've checked, the timeouted job is cancelled properly.
Could you please provide a self-contained example which indicates the problem?
For me it seems that some part of APIClient.getLifeEventTypes is not cooperative

[CristianCardosoA]

The problem I think as you said is not cooperative.

APIClient.getLifeEventTypes 

Is a suspendCancellableCoroutine, but the timeout doesn't cancel the parent job properly.

[qwwdfsad]

Then please provide a self-contained snippet of code which reproduces the problem, I'll take a look

[CristianCardosoA]

Here is my code :D

fun main(){

  val result = withTimeoutOrNull(mTimeoutDownloadDefault){

          job = launch(exceptionLogger) {

                    try {

                          download()

                    } catch (e : Exception) {

                           mError = true
                    }
          }

          job.join()
   }

   If(result == null){
        mError = true
    }  
 }

private suspend fun download() {

    val job = launch {
        APIClient.getLifeEventTypes(this@DownloadManager).await()
    }
    job.join()
}



 fun getLifeEventTypes(context: Context) = async(CommonPool) {

    val clazz = Array<LifeEventType>::class.java

    val builtUri = Uri.parse(BuildConfig.BASE_URL)
            .buildUpon()
            .appendEncodedPath(context.getString(R.string.endpoint_url_lifeEvent_type))
            .build()

    try {

        process(context, builtUri.toString(), clazz, RequestJSONArrayRequestWithHeaders::class.java).filterNotNull().toTypedArray()

    } catch (e : Exception){

        return@async null
    }
}

private suspend inline fun <T,P> process(context: Context, url : String, clazz: Class<T>, typeOfRequest : Class<P>): T = suspendCancellableCoroutine { continuation ->


    val request: Request<*> = when(typeOfRequest){

        RequestStringRequestWithHeaders::class.java -> RequestStringRequestWithHeaders(context,url,continuation,clazz)
        RequestJSONArrayRequestWithHeaders::class.java -> RequestJSONArrayRequestWithHeaders(context,url,continuation,clazz)

        else -> {
            RequestStringRequestWithHeaders(context,url,continuation,clazz)
        }
    }

    request.retryPolicy = DefaultRetryPolicy(120_000,
            DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
            DefaultRetryPolicy.DEFAULT_BACKOFF_MULT)

    NetworkManager.getInstance(context).addToRequestQueue(request)
    continuation.invokeOnCancellation {
        request.cancel()
    }
} 



 class RequestJSONArrayRequestWithHeaders<T> (val context : Context, url : String, continuation: Continuation<T>, clazz: Class<T>) : JsonArrayRequest(Method.GET, url, null,

        Response.Listener {

            val array : T = Gson().fromJson(it.toString(),clazz)
            Log.i(TAG, "$url: $it")
            continuation.resume(array)

        }, Response.ErrorListener {
            continuation.resumeWithException(it.cause ?: Exception("Unknown exception"))
        }
) {
    override fun getHeaders(): Map<String, String> {

        return FNAuthManager.authHeaders?.let {

            it[context.getString(R.string.endpoint_accept_key)] = context.getString(R.string.endpoint_json)
            Log.i(TAG, it.toString())
            it
        } ?: run<JsonArrayRequest, HashMap<String, String>> {
            HashMap()
        }
    }
}

[qwwdfsad]

It looks like you forgot to instantiate a parent:

private suspend fun download() {

    val job = launch {
        APIClient.getLifeEventTypes(this@DownloadManager).await()
    }
    job.join()
}

When block responsible for downloading is cancelled, neither inner launch nor nested async are cancelled.

To properly cancel it, you should pass coroutineContext or parent explicitly:

private suspend fun download() {

    val job = launch(coroutineContext) {
        // getLifeEventTypes should start with async(CommonPool, parent = coroutineContext[Job])
        APIClient.getLifeEventTypes(this@DownloadManager).await()
    }
    job.join()
}

Hopefully it will be fixed automagically with #410

[CristianCardosoA]

Thanks ! I will try that and I'll post my results based on your comments.