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

use std::sync::Arc;

use async_taskex::{Response, SharedData, TaskHandler, TaskMessage};
use async_trait::async_trait;

#[derive(Default)]
struct SimpleData;

impl SharedData for SimpleData {}

struct TestHandler;

#[async_trait]
impl TaskHandler<SimpleData> for TestHandler {
    async fn handle(
        &self,
        task_message: TaskMessage,
        _shared_data: Arc<SimpleData>,
    ) -> Result<Response, String> {
        Ok(Response {
            success: true,
            result: Some(task_message.payload),
            error: None,
        })
    }
}

#[async_std::test]
async fn test_handler() {
    let data = Arc::new(SimpleData {});
    let handler = TestHandler;
    let message = TaskMessage {
        task_name: "test_type".into(),
        payload: "Test message".into(),
    };

    let response = handler.handle(message, data.clone()).await.unwrap();
    assert!(response.success);
    assert_eq!(response.result.unwrap(), "Test message");
}