Struct BackgroundTask

pub struct BackgroundTask { /* private fields */ }

A helper to periodically run a background task until shutdown is requested

Can be used to spawn a separate thread or as a building block for some other (synchronous/blocking) abstraction.

The implementation is little more than a Condvar and some helper methods.

Implementations

impl BackgroundTask

pub fn request_start(&self) -> Result<(), Error>

Mark the task as ready to run

pub fn request_stop_and_notify(&self) -> Result<(), Error>

Request the task to stop

pub fn should_keep_running(&self, timeout: Duration) -> Result<bool, Error>

Wait for a stop request for up to timeout

Usable in a loop like:

while task.should_keep_running(timeout)? {
    do_things_on_every_timeout()?;
}

pub fn spawn<F>( self: &Arc<Self>, interval: Duration, func: F, ) -> Result<JoinHandle<Result<(), Error>>, Error>

where F: FnMut() -> Result<(), Error> + 'static + Send,

Spawn a background thread that calls func every interval until shutdown

Ideally, the called closure should not block for any noticeable time, as shutdown requests are not processed while it’s running.

This method does not attempt to compensate for the closure running time and does not try to guarantee that it’s executed exactly every interval. If you need precise intervals between each execution, you should start the thread yourself and calculate the timeout passed to BackgroundTask::should_keep_running every time. You will also need to handle the case when the closure takes longer than the interval:

• just skip the next execution?
• try to catch up by running the closure back-to-back without a delay?
• return an error (and stop the background thread)?

Trait Implementations

impl Debug for BackgroundTask

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BackgroundTask

fn default() -> BackgroundTask

Returns the “default value” for a type.