async-task-executor 0.1.2

A lightweight Rust library for building extensible asynchronous task executors, designed for handling large-scale multitasking in server environments.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::error::Error;

use async_std::sync::Arc;
use async_taskex::{Response, SharedData, TaskExecutor, TaskHandler, TaskMessage};
use async_trait::async_trait;

pub struct ExampleData {}

impl SharedData for ExampleData {}

struct ExampleTaskHandler;

#[async_trait]
impl TaskHandler<ExampleData> for ExampleTaskHandler {
    async fn handle(
        &self,
        task_message: TaskMessage,
        _shared_data: Arc<ExampleData>,
    ) -> Result<Response, String> {
        println!(
            "Received - task name({}), message({})",
            task_message.task_name, task_message.payload
        );

        let mut result = task_message.payload.clone();
        result.push_str(" World!");

        Ok(Response {
            success: true,
            result: Some(result),
            error: None,
        })
    }
}

#[async_std::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let shared_data = Arc::new(ExampleData {});
    let task_executor: TaskExecutor<ExampleData> = TaskExecutor::new(shared_data);

    let task_handler = ExampleTaskHandler {};

    task_executor
        .register("task name".to_string(), Arc::new(task_handler))
        .await;

    let response = task_executor
        .execute(TaskMessage {
            task_name: "task name".into(),
            payload: "Hello".into(),
        })
        .await?;

    if response.success {
        println!("Response - {}", response.result.unwrap());
    }

    Ok(())
}