floxide 3.2.2

A directed graph workflow system in Rust
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

use floxide::node;
use floxide::workflow;
use floxide::{node::Node, transition::Transition, Workflow};

// A simple stub node that just passes through a value or fails once for retry demo
// Define a printing node that finishes the workflow
node! {
    pub struct StubNode { name: &'static str };
    context = ();
    input = ();
    output = ();
    |_ctx, _x| {
        Ok(Transition::Next(()))
    }
}

impl StubNode {
    fn new(name: &'static str) -> Self {
        Self { name }
    }
}

workflow! {
    pub struct ExampleWorkflow {
        #[retry = retry_policy]
        retry_policy: StubNode,
        start: StubNode,
        task_a: StubNode,
        task_b: StubNode,
        fallback_a: StubNode,
        task_c: StubNode,
        task_d: StubNode,
        join_point: StubNode,
        end_node: StubNode,
    }
    start = start;
    context = ();
    edges {
        // linear path
        start => { [ task_a ] };
        task_a => { [ task_b ] };
        task_b => { [ end_node ] };

        // retry on TaskB
        task_b on_failure => { [ task_a ] };

        // fallback on TaskA
        task_a on_failure => { [ fallback_a ] };

        // composite branch example
        task_b => {
            // pretend TaskB can output two variants
            // but using the same stub values
            StubNode::Branch(x) => [ task_c ];
            StubNode::Branch2(x) => [ task_d ];
        };

        // parallel then join
        task_c => { [ join_point ] };
        task_d => { [ join_point ] };
        join_point => { [ end_node ] };

        // fallback on TaskC
        fallback_a  => { [ end_node ] };

        // terminal
        end_node => {};
    }
}

fn main() {
    // Build the workflow instance
    let wf = ExampleWorkflow {
        retry_policy: StubNode::new("RetryPolicy"),
        start: StubNode::new("Start"),
        task_a: StubNode::new("TaskA"),
        task_b: StubNode::new("TaskB"),
        fallback_a: StubNode::new("FallbackA"),
        task_c: StubNode::new("TaskC"),
        task_d: StubNode::new("TaskD"),
        join_point: StubNode::new("JoinPoint"),
        end_node: StubNode::new("End"),
    };

    // Generate and print the DOT graph
    let dot = wf.to_dot();
    println!("{}", dot);
}