freactor 0.1.5

A lightweight framework for asynchronous execution flow.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

# Freactor
![crates.io](https://img.shields.io/crates/v/freactor)
![docs.rs](https://docs.rs/freactor/badge.svg)
![License](https://img.shields.io/crates/l/freactor)

A lightweight framework for asynchronous execution flow in Rust.

## Table of Contents

- [Description](#description)
- [Installation](#installation)
- [Usage](#usage)
- [Examples](#examples)
- [API Reference](#api-reference)
- [Contributing](#contributing)
- [License](#license)
- [Contact](#contact)

## Description

Freactor is a lightweight and flexible framework designed to manage and execute asynchronous flows in Rust. It provides an easy-to-use API to define and execute asynchronous tasks, making it ideal for building complex workflows and state machines.

## Installation

Add with cargo command:
```
cargo add freactor
```

Or you can add `freactor` to your `Cargo.toml`:
```toml
[dependencies]
freactor = "0.1"
```

## Usage

Here's a quick example to get you started:
```
/* 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 {...}))
    f.run("ExampleTask1", workspace_state).await;

}
```

## Examples

Here are some examples to illustrate how to use freactor for different scenarios:

**Example 1: Multi-Threaded Parallel Execution**
```
/* To be continued */
```

**Example 2: HTTP Web Server Integration**
```
/* To be continued */
```


## API Reference

For detailed API reference, please visit [docs.rs](https://docs.rs/freactor/latest/freactor/).

## Contributing

Welcome contributions from the community! Please read our [CONTRIBUTING](CONTRIBUTING.md) guide to learn how you can help.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Contact

If you have any questions, feel free to reach out:

- GitHub: https://github.com/Pro-YY
- Email: paulyyangyang@gmail.com