Cannot start a runtime from within a runtime

[Osiris9999]

I am trying to create a telegram bot with teloxide

scrape.rs

use error_chain::error_chain;
use rand::Rng;
use scraper::{Html, Selector};
use select::document::Document;
use select::predicate::Name;
use std::{borrow::Cow, io};

error_chain! {
      foreign_links {
          ReqError(reqwest::Error);
          IoError(std::io::Error);
      }
}

#[tokio::main]
pub async fn main() -> Result<String> {
    let body = reqwest::get("http://www.funnyshortjokes.com/")
        .await?
        .text()
        .await?;

    let document = Html::parse_fragment(&body);
    let selector = Selector::parse("p").unwrap();
    let mut jokes = document
        .select(&selector)
        .map(|joke| joke.text().collect::<String>())
        .collect::<Vec<_>>();

    let p = document.select(&selector).next().unwrap();

    let text = p.text().collect::<Vec<_>>();
    let elements = document.select(&selector);

    let mut rng = rand::thread_rng();
    let mut n = rng.gen_range(0..10);
    println!("{:#?}", jokes[n]);

    let mut s = jokes[n].clone();

    Ok(s)
}

There is no error while compiling and it runs perfectly but when I type /j on telegram it gives me this error

thread 'tokio-runtime-worker' panicked at '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.'

I don't understand what i can do to solve this. I haven't seen this anywhere on the internet yet.

[Darksonn]

When you annotate a function with #[tokio::main], that turns the function into this:

fn main() {
    tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(async {
            ...
        })
}

So that means that if you call a method annotated with #[tokio::main] from asynchronous code, you are creating a new runtime while being in asynchronous code.

Remove the #[tokio::main] annotation from scape::main.

[brandonros]

Can you "block_on" multiple futures at once?

[Darksonn]

@brandonros If you have a runtime object, then you could spawn the futures like this:

let task1 = rt.spawn(future1);
let task2 = rt.spawn(future2);
let task3 = rt.spawn(future3);
let (output1, output2, output3) = rt.block_on(async { (task1.await, task2.await, task3.await) });

Because of how spawn works, this will run all of them concurrently. Another option is to use the tokio::join! macro like this:

let (output1, output2, output3) = rt.block_on(async {
    tokio::join!(future1, future2, future3)
});

However spawning is preferable for performance reasons, so you should prefer it unless the 'static requirement is a problem for your use-case.

(Since you asked about block_on, this answer assumes that you are not already inside the runtime.)

[brandonros]

I run into a really weird edge case where, I am not able to have async fn as far as "outside" is concerned.

For example,

static ref dpdu_library: minidl::Library = minidl::Library::load(dpdu_library_dll_path.clone()).unwrap();
  static ref PDUConstruct: PDUConstructFn  = unsafe { dpdu_library.sym("PDUConstruct\0").unwrap() };

#[no_mangle]
extern "stdcall" fn PDUConstruct(OptionStr: *mut CHAR8, pAPITag: *mut ::std::os::raw::c_void) -> T_PDU_ERROR {
  // how to make an async call here
}

For C/C++ interop FFI wise, I can't have the external function be async. Ok, no problem. do rt.block_on.

But I run into cases where, one non-async function that calls into async functions via block_on needs to call another and it gets nested and weird... I haven't come up with the right way to do it so far.

I'm not 100% sure (I could be wrong) but it feels like despite tokio offering multi-threader runtime executor, I can't have multiple block_on? Is that the truth?

[brandonros]

It'd be cool if I could do like

let task_handle = tokio::spawn(async { ... } );
let return_value = wait_for_task_handle_to_finish_without_calling_await(task_handle); // can't do task_handle.await since in a non async context

[Darksonn]

Open a new question if you have a new question.