https://github.com/dapper91/coachman-rs
rust asynchronous task manager built on top of tokio framework supporting task cancellation feature
https://github.com/dapper91/coachman-rs
async asynchronous cancellable rust rust-lang supervisor task-manager tokio
Last synced: 11 months ago
JSON representation
rust asynchronous task manager built on top of tokio framework supporting task cancellation feature
- Host: GitHub
- URL: https://github.com/dapper91/coachman-rs
- Owner: dapper91
- License: unlicense
- Created: 2021-11-06T06:59:22.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2021-11-21T08:42:23.000Z (about 4 years ago)
- Last Synced: 2025-03-08T07:04:13.807Z (11 months ago)
- Topics: async, asynchronous, cancellable, rust, rust-lang, supervisor, task-manager, tokio
- Language: Rust
- Homepage: https://docs.rs/coachman
- Size: 132 KB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# CoachMan
`coachman` is a rust asynchronous task manager built on top of tokio framework.
## Features
* **Task count control:**
`coachman` allows you to control task count preventing your application from uncontrolled task count explosion.
* **Task cancellation:**
The main feature of `coachman` is task cancellation. It provides a simple api for making your task cancelable.
# Basic example
The main feature of coachman is making asynchronous tasks cancelable.
Look at the following example:
``` rust
use coachman as cm;
use coachman::{try_await, Canceled, Completed, TaskError};
async fn inner_func(i: usize, duration: u64) {
match try_await!(tokio::time::sleep(std::time::Duration::from_secs(duration))) {
Canceled => println!("task#{} inner canceled", i),
Completed(_) => println!("task#{} inner completed", i),
}
}
async fn outer_func(i: usize, duration: u64) {
match try_await!(inner_func(i, duration)) {
Canceled => println!("task#{} outer canceled", i),
Completed(_) => println!("task#{} outer completed", i),
}
}
#[tokio::main(flavor = "current_thread")]
async fn main() {
let mut task_handles = Vec::new();
for i in 0..5 {
let duration = i as u64;
task_handles.push(cm::spawn(outer_func(i, duration)));
}
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
for (i, mut handle) in task_handles.into_iter().enumerate() {
if tokio::time::timeout_at(deadline, &mut handle).await.is_ok() {
println!("task-{} completed", i);
} else {
handle.cancel();
match handle.await {
Result::Err(TaskError::Canceled) => println!("task-{} canceled", i),
Result::Err(TaskError::Aborted) => println!("task-{} aborted", i),
Result::Err(TaskError::Panicked(_)) => println!("task-{} panicked", i),
Result::Ok(_) => unreachable!(),
}
}
}
}
```