How to modify the JobQueue to run under Tokio?

[ivansanchez-oss]

Hi, I'm want to replicate the example shown in futures.rs but with two differences, the first is using tokio and the second is that the main program is already under the asynchronous runtime with #[tokio::main].

I understand that somehow I have to use an executor but I don't see anything similar to smoll::LocalExecutor in tokio, any advice to make this example work? I thought tokio::task::LocalSet would be the solution but I have no way to call await inside of run_jobs.

struct SomeTokioExecutor;

impl SomeTokioExecutor {
    pub fn run(&self, _future: impl Future<Output = ()>) {
        unimplemented!()
    }
}

struct Queue {
    executor: SomeTokioExecutor,
    futures: RefCell<FuturesUnordered<FutureJob>>,
    jobs: RefCell<VecDeque<NativeJob>>,
}

impl JobQueue for Queue {
    fn enqueue_promise_job(&self, job: NativeJob, _context: &mut Context) {
        self.jobs.borrow_mut().push_back(job);
    }

    fn enqueue_future_job(&self, future: FutureJob, _context: &mut Context) {
        self.futures.borrow().push(future);
    }

    fn run_jobs(&self, _context: &mut Context) {
        if self.jobs.borrow().is_empty() && self.futures.borrow().is_empty() {
            return;
        }

        let future = async move {
            let fut_queue = async { /* do somathing  */ };
            let job_queue = async { /* do something */ };

            // wait for both queues to complete
            futures_util::join!(fut_queue, job_queue);
        };

        self.executor.run(future);
    }
}

#[tokio::main]
async fn main() {
    let queue = Queue {
        executor: SomeTokioExecutor,
        futures: RefCell::default(),
        jobs: RefCell::default(),
    };

    let _context = &mut ContextBuilder::new()
        .job_queue(Rc::new(queue))
        .build()
        .unwrap();
}