Another question :slightly_smiling_face: Why is th...

# coroutines

[vaskir]

Another question 🙂 Why is this warning? As I understand, it's the recommended way to wrap IO-bound blocking calls with <http://Dispatchers.IO|Dispatchers.IO>

[pawegio]

it’s blocking thread, but is it cancellable?

[streetsofboston]

I think the linting that produces this warning is not able to look a few steps up the hierarchy and see the <http://Dispatchers.IO|Dispatchers.IO> there.

Move the call to `withContext down to just before/around calling process.waitFor should get rid of the warning. Or otherwise, just suppress the warning 🙂

[vaskir]

same

[vaskir]

hmm. Is there a documentation for this warning? The algorithm?

[vaskir]

waitFor is not cancellable.

[vaskir]

It's just throw if timed out

[streetsofboston]

This lint warning is produced if the call is declared to be able to throw an IOException and this call is not directly wrapped inside a withContext(<http://Dispatchers.IO|Dispatchers.IO>) call.

[streetsofboston]

It produces false warnings if the dispatcher was switched to the IO one earlier and if your code injects the dispatchers and not ‘hard-code’ the Dispacthers.IO.

I has nothing to do with being cancellable or not.

[vaskir]

BTW, maybe there's a well behaving, idiomatic way to run a process, with timeout and cancellation?

[vaskir]

I'm using

val process = ProcessBuilder(*parts.toTypedArray())
  .directory(workingDir)
  .redirectOutput(ProcessBuilder.Redirect.PIPE)
  .redirectError(ProcessBuilder.Redirect.PIPE)
  .start()

[streetsofboston]

You can’t cancel a blocking call. At best you can interrupt the thread that is blocked but that can be dangerous

[streetsofboston]

You can cancel a suspending call, though, but that is different 🙂

[vaskir]

Yes, I understand.

[marstran]

Do you really need the separate call to withContext ? Can't you just do this:

launch(<http://Dispatchers.IO|Dispatchers.IO>) {
    process.waitFor(....)
}

[vaskir]

I think about a process runner, which, being cancelled, kill the process or something like this.

[vaskir]

@marstran aha! The warning has gone.

[vaskir]

But I think withContext is what is recommended to use, isn't it?

[streetsofboston]

If you want to cancel something:

suspendCancellableCoroutine<Unit> { cont ->
    val handle = startBlockingProcess(....)
    cont.invokeOnCancelation { handle.cancel() }
    cont.resume(Unit)
}

[streetsofboston]

(assuming handle represents a process that can be cancelled by calling cancel() or something similar on it)

[vaskir]

aha. I just read about this function yesterday 🙂

[vaskir]

thanks.

[streetsofboston]

You may need to do handle.awaitResult() or handle.join() or what-ever would be the correct function name, just before calling cont.resume(Unit)

[vaskir]

Should I handle exceptions inside it?

[streetsofboston]

Yup, catch them and do cont.resumeWithException(e)

[vaskir]

ok

[streetsofboston]

But this depends on how you model your app’s data model. You can catch the exception and then handled it by returning an error-value instead (cont.resume(errorData))

[vaskir]

got it