Quick launch question. I have a method I have to implement. It's called externally, and isn't expected to return till the spawned coroutine exits. I used

runBlocking

with great results. But, now I want to use a scope for the class. I have this:

private val scope = CoroutineScope(serverCoroutineDispatcher )

    fun doWork() {
        runBlocking(scope.coroutineContext) {
            //.....
        }
    }

The runBlocking with the scope's context feels wrong. I could

scope.launch

but then it would return instantly. What am I missing?

I'd say the most correct thing to do is:

runBlocking(ctx.newCoroutineContext(Job(ctx.coroutineContext[Job])))

basically, create a "child" of the context

When you do:

scope.launch { 
    // your stuff
}

inside your

doWork

function it will return instantly (as you noticed) because your function is not suspend or it is not waiting your launch to be completed

here is my proof for

runBlocking

spawning a child job:

val ctx = CoroutineScope(Dispatchers.Default + SupervisorJob())

fun main() {
    try {
        runBlocking(ctx.coroutineContext) {
            println("I am running...")
            println("But now I will cancel the job by throwing! If I'm not a child coroutine, this _will_ cancel the ctx")
            error("Test error")
        }
    } catch (e: Exception) {
        println("The other runBlocking bailed out: ${e.message}")
    }
    runBlocking(ctx.coroutineContext) {
        println("[A] I will never run if my Job is cancelled.")
    }
    // explicitly cancel now
    ctx.coroutineContext.cancel()
    runBlocking(ctx.coroutineContext) {
        println("[B] I will never run if my Job is cancelled.")
    }
}

results in

I am running...
But now I will cancel the job by throwing! If I'm not a child coroutine, this _will_ cancel the ctx
The other runBlocking bailed out: Test error
[A] I will never run if my Job is cancelled.
Exception in thread "main" kotlinx.coroutines.JobCancellationException: Job was cancelled; job=SupervisorJobImpl{Cancelled}@3e57cd70

I have code that looks like this this:

suspend fun disconnect(reason: DisconnectReason) {
        withContext(coroutineContext){
            agentConnection.send(Frame().setCommand(Frame.Command.DISCONNECT))
            agentConnection.close(reason)
        }
    }

In this case, the caller is an old legacy system. They're expecting the method to block until it's complete.