Is it possible create background task wich should do something.

[heckad]

I want to print an app state every minute. To solve this problem, I need to do something that will work in the background and when I exit from a scope this background task should stop.
For example

async fn some_func() {
    let monitoring  = BackgroundWorker::new(move || info!("Current state ..."));

    // Do something
    // When exit we in drop should stop background task.
}

How to do this or maybe we have a library yet?

[Darksonn]

The easiest way to kill the task when you exit the scope is to use remote_handle from the futures-util crate. Note that this requires your state to be share-able in some manner. If your state is currently not share-able, the mini-redis example has an illustration of a common way of sharing mutable state in db.rs.

use tokio::time::{self, Duration};

async fn some_func(state: AppState) {
    let (job, _handle) = futures_util::future::FutureExt::remote_handle(monitor(state.clone()));
    tokio::spawn(job);

    // do stuff

    // _handle goes out of scope here, which kills the task
}

async fn monitor(state: AppState) {
    let mut interval = time::interval(Duration::from_secs(60)); // or delay_for
    loop {
        interval.tick().await;
        info!("App state is {:?}", state);
    }
}

As an alternative to remote_handle, there is also abortable from the futures crate, but you have to explicitly call abort when using this tool. If using abortable, consider defining a destructor on some value and calling abort() in the destructor, as you otherwise risk leaking the task in case of panics.

---

As an alternative, you can use the select! macro instead of spawning.

use tokio::time::{interval, Duration};

async fn some_func(state1: AppState) {
    let state2 = state1.clone();
    tokio::select! {
        _ = do_stuff(state1) => {},
        _ = monitor(state2) => {},
    }
}

async fn do_stuff(state: AppState) {
    // ...
}

async fn monitor(state: AppState) {
    let mut interval = interval(Duration::from_secs(60));
    loop {
        interval.tick().await;
        info!("App state is {:?}", state);
    }
}

[heckad]

How to use abortable task with tokio::spawn? It would be nice to add an example to the documentation.

[Darksonn]

Similar to remote_handle.

use futures::future::abortable;

let (job, handle) = abortable(task());
tokio::spawn(job);

...

handle.abort();

[heckad]

Thank you very much!