Detect when tokio::sync::mpsc::Receiver::blocking_recv is called from async context

[danchia]

In my library, I have a function f that sometimes (but not always) ends up calling tokio::sync::mpsc::Receiver::blocking_recv.

The expected usage is that f is not called from within an asynchronous context, however this sometimes this requirement is missed. Unfortunately, this means that f sometimes (but not always) panics due to use of blocking_recv.

It would be great to be able to add a debug_assert! within f to make sure blocking_recv will succeed, however best I can tell this requires access to tokio::runtime::enter::* which is not public.

Is there another way to achieve what I'm after?

[Noah-Kennedy]

You can use https://docs.rs/tokio/latest/tokio/runtime/struct.Handle.html#method.try_current to check if you are currently in a runtime context.

[danchia]

Unfortunately, I don't think Handle::try_current works - the runtime context is not the same as the execution context detected by tokio::runtime::enter::try_enter

 // panics, block_on in async context
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test1() -> Result<()> {
    let (tx, _) = tokio::sync::mpsc::channel(100);
    let _ = tx.blocking_send(1);
    Ok(())
}

// runs fine
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test1() -> Result<()> {
    let (tx, _) = tokio::sync::mpsc::channel(100);
    tokio::task::block_in_place(|| {
        let _ = tx.blocking_send(1);
    });
    Ok(())
}

// assertion fails
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test1() -> Result<()> {
    let (tx, _) = tokio::sync::mpsc::channel(100);
    tokio::task::block_in_place(|| {
        // Check we are not in an async context.
        assert!(matches!(tokio::runtime::Handle::try_current(),
            Err(e) if e.is_missing_context()));
        let _ = tx.blocking_send(1);
    });
    Ok(())
}

[Darksonn]

I don't think there's any other way than catching the panic.

[danchia]

I am not trying to prevent the panic. Rather, I want to make my code panic whenever blocking_send would have panic-ed due to being in an async context. The problem I have is that my code looks more like this:

fn do_stuff(&self) {
  if self.some_occasional_condition() {
     self.blocking_send(()).unwrap()
  }
}

so it's easy for tests to pass even when we call do_stuff from an async context when we shouldn't. Being able to add a debug_assert!(is_in_async_context()) to do_stuff would let us catch bugs sooner.

[Darksonn]

If you call block_on on a Handle, it will panic in the same circumstances as blocking_send. So you can simply handle.block_on(async {})

[danchia]

Oh that's a neat idea. Thank you very much!