Struct TaskManager 

pub struct TaskManager { /* private fields */ }

Task manager is an asynchronous task supervisor that stores all spawned tasks, controls its states and provides an api for task management.

Implementations

impl TaskManager

pub fn builder() -> TaskManagerBuilder

Returns a task manager builder.

Examples found in repository

examples/task_manager.rs (line 24)

async fn main() {
    let mut task_manager = cm::TaskManager::builder().with_max_tasks(10).with_capacity(10).build();

    let mut task_keys = Vec::new();
    for i in 0..10 {
        let task_key = task_manager.try_spawn(outer(i)).unwrap();
        task_keys.push(task_key)
    }

    tokio::time::timeout(time::Duration::from_secs(5), task_manager.process(false)).await;

    for task_key in task_keys {
        if task_manager.cancel_task(task_key).is_ok() {
            println!("task-{} canceled", task_key)
        } else {
            println!("task-{} already finished", task_key)
        }
    }

    task_manager.join(true).await;
}

pub fn new( max_tasks: usize, capacity: usize, completion_events_buffer_size: usize, ) -> TaskManager

Creates a new task manager instance.

pub fn size(&self) -> usize

Returns manager task count.

pub fn try_spawn<F>(&mut self, future: F) -> Option<usize>

where F: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task wrapping it to be supervised by the task manager. Method can return None if task manager is full and task can not be spawned yet otherwise it returns task key that can be used to cancel this task.

Examples found in repository

examples/task_manager.rs (line 28)

async fn main() {
    let mut task_manager = cm::TaskManager::builder().with_max_tasks(10).with_capacity(10).build();

    let mut task_keys = Vec::new();
    for i in 0..10 {
        let task_key = task_manager.try_spawn(outer(i)).unwrap();
        task_keys.push(task_key)
    }

    tokio::time::timeout(time::Duration::from_secs(5), task_manager.process(false)).await;

    for task_key in task_keys {
        if task_manager.cancel_task(task_key).is_ok() {
            println!("task-{} canceled", task_key)
        } else {
            println!("task-{} already finished", task_key)
        }
    }

    task_manager.join(true).await;
}

pub async fn process(&mut self, resume_panic: bool)

Runs manager processing loop handling task events. Method is cancellation safe and can be used in tokio::select! macro. If resume_panic argument is true and any of the tasks panic method resumes the panic on the current task. It is useful in test environment when you want your application to be panicked if any of the spawned tasks panic.

Examples found in repository

examples/task_manager.rs (line 32)

async fn main() {
    let mut task_manager = cm::TaskManager::builder().with_max_tasks(10).with_capacity(10).build();

    let mut task_keys = Vec::new();
    for i in 0..10 {
        let task_key = task_manager.try_spawn(outer(i)).unwrap();
        task_keys.push(task_key)
    }

    tokio::time::timeout(time::Duration::from_secs(5), task_manager.process(false)).await;

    for task_key in task_keys {
        if task_manager.cancel_task(task_key).is_ok() {
            println!("task-{} canceled", task_key)
        } else {
            println!("task-{} already finished", task_key)
        }
    }

    task_manager.join(true).await;
}

pub fn detach( &mut self, task_key: usize, ) -> Result<TaskHandle<()>, TaskManagerError>

Detaches a task from the manager. The task is not longer supervised by the manager.

pub fn cancel(self)

Cancels all supervised tasks.

pub fn abort(self)

Aborts all supervised tasks, consuming self.

pub async fn join(self, resume_panic: bool)

Waits until all the tasks are completed consuming self. If resume_panic argument is true and any of the tasks panic method resumes the panic on the current task. It is useful in test environment when you want your application to be panicked if any of the spawned tasks panic.

Examples found in repository

examples/task_manager.rs (line 42)

async fn main() {
    let mut task_manager = cm::TaskManager::builder().with_max_tasks(10).with_capacity(10).build();

    let mut task_keys = Vec::new();
    for i in 0..10 {
        let task_key = task_manager.try_spawn(outer(i)).unwrap();
        task_keys.push(task_key)
    }

    tokio::time::timeout(time::Duration::from_secs(5), task_manager.process(false)).await;

    for task_key in task_keys {
        if task_manager.cancel_task(task_key).is_ok() {
            println!("task-{} canceled", task_key)
        } else {
            println!("task-{} already finished", task_key)
        }
    }

    task_manager.join(true).await;
}

pub fn cancel_task(&mut self, task_key: usize) -> Result<(), TaskManagerError>

Cancels a particular task by task key returned by TaskManager::try_spawn method. If task not found (task key is wrong or task already finished) method returns TaskManagerError::TaskNotFound error.

Examples found in repository

examples/task_manager.rs (line 35)

async fn main() {
    let mut task_manager = cm::TaskManager::builder().with_max_tasks(10).with_capacity(10).build();

    let mut task_keys = Vec::new();
    for i in 0..10 {
        let task_key = task_manager.try_spawn(outer(i)).unwrap();
        task_keys.push(task_key)
    }

    tokio::time::timeout(time::Duration::from_secs(5), task_manager.process(false)).await;

    for task_key in task_keys {
        if task_manager.cancel_task(task_key).is_ok() {
            println!("task-{} canceled", task_key)
        } else {
            println!("task-{} already finished", task_key)
        }
    }

    task_manager.join(true).await;
}

pub fn abort_task(&mut self, task_key: usize) -> Result<(), TaskManagerError>

Aborts a task by a task key. The task is removed from the storage so that it can’t be accessed anymore.