Freactor

Freactor是一个Rust中异步执行流程的轻量级框架，旨在快速、可靠、可扩展且易于使用。

目录

• 概述
• 安装
• 用法
• 示例
• API参考
• 贡献
• 许可证
• 联系

概述

Freactor是一个轻量级且灵活的框架，旨在管理和执行Rust中的异步流程。它提供了一个易于使用的API来定义和执行异步任务，非常适合构建复杂的工作流和状态机。

安装

使用cargo命令添加

cargo add freactor

或者，您可以将freactor添加到您的Cargo.toml

[dependencies]
freactor = "0.1"

用法

以下是一个快速入门示例

/* Your async function implementations, and function map here. */
async r1() {}
async r2() {}
async r3() {}
...


async run () {
    // 1. Define business flow config
    let flow_config = r#"
    {
        "ExampleTask1": {
            "init_step": "r1",
            "config": {
                "r1": { "edges": ["r2", "r3", "r4"]},
                "r2": { "edges": ["r5", "r3"]},
                "r3": { "edges": ["r6", "r4"]},
                "r4": { "edges": []},
                "r5": { "edges": ["r6", "r3"]},
                "r6": { "edges": [], "retry": null}
            }
        }
    }
    "#.to_string();

    // 2. Init freactor with funcs and config
    let f = Freactor::new(func_map, flow_config);

    // 3. Prepare you workspace arc state, and run your flow later anywhere
    let state = Arc::new(Mutex::new(State:new(YOUR_BUSINESS_DATA)))
    f.run("ExampleTask1", workspace_state).await;

}

示例

以下是一些示例，说明了如何在不同场景中使用freactor

示例1：多线程并行执行

// run with independent self data(state)

async fn run() {
    // function map and flow config here...
    let f = Freactor::new(func_map, flow_config);

    // multiple flow instance concurrently
    let mut shared_vecs: Vec<Arc<Mutex<State>>> = Vec::with_capacity(10);
    for i in 0..shared_vecs.capacity() {
        let state = State::new(...);
        shared_vecs.push(Arc::new(Mutex::new(state)));
    }

    let mut jset = JoinSet::new();
    for v in shared_vecs.clone() {
        let fc = f.clone();
        jset.spawn(async move {
            let _ = fc.run("Task1", v).await;
        });
    }
    while let Some(_res) = jset.join_next().await {}

    for v in shared_vecs {
        let vec = v.lock().unwrap();
        info!("Mutated Vec: {:?}", *vec);
    }
}

示例2：HTTP Web服务器集成

// with web framework, like Axum
// just put freactor in shared server state (Extension/State) and run your task in handler

async fn handle_task_1(Extension(f): Extension<Arc<Freactor>>) -> &'static str {
    let v = Arc::new(Mutex::new(State::new(...)));
    let _ = f.run("Task1", v).await;
    "Hello, World!"
}

async fn main() {
    // function map and flow config here...
    let f = Freactor::new(func_map, flow_config);
    let shared_server_state = Arc::new(f);

    let app = Router::new()
    .route("/", get(root))
    .route("/1", get(handle_task_1))
    .route("/2", get(handle_task_2))
    .layer(Extension(shared_server_state));

    // run our app with hyper, listening globally on port 3000
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

API参考

有关详细的API参考，请访问docs.rs。

贡献

欢迎社区贡献！请阅读我们的CONTRIBUTING指南，了解您如何帮助。

许可证

本项目采用MIT许可证。有关详细信息，请参阅LICENSE文件。

联系

如果您有任何问题，请随时联系我们

• GitHub: https://github.com/Pro-YY
• Email: [email protected]