How to detect panic on a future in LocalSet::spawn_local

[Kxuan]

The code below should panic the 'main' thread. But eventually, the process print backtrace and then exit with code 0. But it is expected to exit with a non-zero code.

use std::time::Duration;

fn main(){
    let basic_rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build().unwrap();
    let local = tokio::task::LocalSet::new();
    local.block_on(&basic_rt, async {
        local.spawn_local(async {
            panic!("failed");
        });
    });
    local.block_on(&basic_rt, async {
        tokio::time::sleep(Duration::from_secs(1)).await;
    });
}

More specifically, I am writing unit tests. Some code panic in local.spawn_local. But the test case is finished with a PASS. So how can I detect the future in local.spawn_local is panic and mark the test case as FAILED?

[Darksonn]

You will need to .await (or block_on) the JoinHandle that it returns and check its return value for errors.

Unfortunately, there's no way to change how the runtime handles panics.

[Kxuan]

By calling .await, the control flow becomes "sync". But it is not what I want.

I have a tcp server listener, and when it receives an incoming connection, the code calls spawn_local to handle the conection "async".
Then some bad code result panic on handling messages from connections.

Could you please tell me another solution? await on connection will result the tcp server listener stop receive new incoming connections.

[Darksonn]

It only becomes "sync" if you immediately .await it. You can do stuff like this:

let handle1 = tokio::spawn(...);
let handle2 = tokio::spawn(...);
handle1.await.unwrap();
handle2.await.unwrap();

You can also put them in a vector and await them in a loop if the number of spawns is variable.

[Kxuan]

Thank you Darksonn . It seems that there is no other way to get the panic except to await JoinHandle. So I will try to collect all spawns in my code and await them in one place.

---

Additionaly, just an advise, it will be better that provide a way to allow user detect the panic without JoinHandle. Or like what rust itself doing, tokio provide a panic handler or panic hook.

When code get more and more complex, the spawn may be called in a really deep function call or even in a third_party code.

For example, the redis crate call spawn for multiplexed_async_connection and drop the JoinHandle immediately. If panic happens in multiplexed_async_connection, there is no way to detect and fail a test.

[Darksonn]

There is already an issue open about this somewhere.