Cannot start a runtime from within a runtime

Cannot start a runtime from within a runtime. This happens because a function (like `block_on`) attempted to block the current thread while the thread is being used to drive asynchronous tasks. If you are in an async function, use `.await` on the future instead of blocking on it.

Cannot drop a runtime in a context where blocking is not allowed. This happens when a runtime is dropped from within an asynchronous context.

Cannot block the current thread from within a runtime. This happens because a function attempted to block the current thread while the thread is being used to drive asynchronous tasks.

// A "sync" helper that someone wrote with its own runtime inside
fn fetch_config_sync() -> String {
  let rt = tokio::runtime::Runtime::new().unwrap();
  rt.block_on(async { "config".to_string() })
}

fn main() {
  quiet_hook();
  let rt = tokio::runtime::Runtime::new().unwrap();

  case(&rt, "1. sync helper with its own Runtime, called from async", async {
    let _ = fetch_config_sync();
  });

  case(&rt, "2. Handle::current().block_on inside async", async {
    tokio::runtime::Handle::current().block_on(async {});
  });

  case(&rt, "3. build a Runtime inside async and drop it", async {
    let inner = tokio::runtime::Runtime::new().unwrap();
    drop(inner);
  });

  case(&rt, "4. mpsc::Receiver::blocking_recv inside async", async {
    let (tx, mut rx) = tokio::sync::mpsc::channel::<u8>(1);
    tx.send(1).await.unwrap();
    let _ = rx.blocking_recv();
  });

  case(&rt, "5. Mutex::blocking_lock inside async", async {
    let m = tokio::sync::Mutex::new(0);
    let _g = m.blocking_lock();
  });
}

1. sync helper with its own Runtime, called from async
  panic: Cannot start a runtime from within a runtime. This happens because a function (like `block_on`) attempted to block the current thread while the thread is being used to drive asynchronous tasks. If you are in an async function, use `.await` on the future instead of blocking on it.
2. Handle::current().block_on inside async
  panic: Cannot start a runtime from within a runtime. This happens because a function (like `block_on`) attempted to block the current thread while the thread is being used to drive asynchronous tasks. If you are in an async function, use `.await` on the future instead of blocking on it.
3. build a Runtime inside async and drop it
  panic: Cannot drop a runtime in a context where blocking is not allowed. This happens when a runtime is dropped from within an asynchronous context.
4. mpsc::Receiver::blocking_recv inside async
  panic: Cannot block the current thread from within a runtime. This happens because a function attempted to block the current thread while the thread is being used to drive asynchronous tasks.
5. Mutex::blocking_lock inside async
  panic: Cannot block the current thread from within a runtime. This happens because a function attempted to block the current thread while the thread is being used to drive asynchronous tasks.

fn fetch_config_sync() -> String {
  let rt = Runtime::new().unwrap();
  rt.block_on(async { "config".to_string() })
}

async fn fetch_config() -> String {
  "config".to_string()
}

#[tokio::main]
async fn main() {
  // Fix 1: you are already async -- just await
  println!("1. await: {}", fetch_config().await);

  // Fix 2: run the sync helper on a blocking thread (its runtime lives and dies there)
  let v = tokio::task::spawn_blocking(fetch_config_sync).await.unwrap();
  println!("2. spawn_blocking(sync helper): {v}");

  // Fix 3: block_in_place + the current Handle (multi_thread only)
  let v = tokio::task::block_in_place(|| Handle::current().block_on(fetch_config()));
  println!("3. block_in_place + Handle::block_on: {v}");

  // Fix 4: a runtime created in async must not be dropped with a blocking wait
  let inner = Runtime::new().unwrap();
  let v = inner.spawn(fetch_config()).await.unwrap();
  inner.shutdown_background();
  println!("4. inner runtime + shutdown_background: {v}");
}

1. await: config
2. spawn_blocking(sync helper): config
3. block_in_place + Handle::block_on: config
4. inner runtime + shutdown_background: config