Best practice: return a blocking future or JoinHandle?

[maxcountryman]

Hi folks,

I have a method, run, that's part of the public API of a crate I'm building. The purpose of this method is to start two background tasks: a worker and a scheduler. These tasks need to run in parallel, so they are spawned using tokio::spawn and then managed with tokio::select!. (Note that both tasks run indefinitely, so the select! is not expected to resolve under normal operation.)

Currently, this run method blocks when called. Callers can tokio::spawn the future if they prefer (and generally would, since this crate aims to provide durable background jobs). However, I’m considering an alternative approach: spawning the select! future within the run method and returning the JoinHandle. This would give callers the flexibility to block on the handle or ignore it. That could be something like:

  pub async fn run(&self) -> JoinHandle<Result<()>> {
        let worker = Worker::from(self);
        let scheduler = Scheduler::from(self);

        let worker_task = tokio::spawn(async move { worker.run().await });
        let scheduler_task = tokio::spawn(async move { scheduler.run().await });

        tokio::spawn(async {
            tokio::select! {
                res =  worker_task => {
                    match res {
                        Ok(inner_res) => inner_res.map_err(Error::from),
                        Err(join_err) => Err(Error::from(join_err)),
                    }
                },

                res = scheduler_task => {
                    match res {
                        Ok(inner_res) => inner_res.map_err(Error::from),
                        Err(join_err) => Err(Error::from(join_err)),
                    }
                },
            }
        })
    }

Alternatively, I could provide a separate method, maybe called start, that wraps run with tokio::spawn as a convenience.

All that said, I'm looking for guidance on common idioms for this pattern and how best to apply them in my specific use case. Which approach is more idiomatic or recommended?