Are async < sync < async patterns possible for initialization-type tasks?

[tgross35]

#[tokio::main]
async fn main() {
    one_time_initialize();
    main_task().await
}


fn one_time_initialize() {
    // ...
    block_on(some_async_task())
    // ...
}

This is a simplification, but one_time_initialize must complete before main_task starts. one_time_initialize has to be sync for compatibility with other parts of the system (a refactor is possible, but it's kind of a last resort).

I have considered or tried the following:

1. Using Handle::current().block_on(|| ...) within the sync functions: this panics because of using runtimes within runtimes
2. Using task::spawn_blocking: This works without conflict, but it doesn't stop the current thread's execution
3. Using the above with a sync std mpsc channel that blocks until one_time_initialize sends completion status (or thread::park)
4. Calling the sync portion before starting the runtime manually (unfortunately ergonomics here would be difficult)

Option 3 seems like the best but none of these options seem all that great, so I'm simply wondering if there is a better solution. Completely stopping the main runtime until one_time_initialize is acceptable and probably necessary, but I'm not sure how to do that.

[Darksonn]

In a multi-thread runtime, you can use block_in_place around the block_on call.

On a current-thread runtime, the possibilities are much more limited. If option 3 works, then you could do that, but if your initialization requires any runtime resources (e.g. if it needs to do any async IO), then it is simply impossible.

[tgross35]

I haven’t come across block_in_place, so I will take a look at that. Thank you!