acts 0.24.0

a fast, lightweight, extensiable workflow engine
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

mod context;
pub(crate) mod cron;
mod process;
mod queue;
mod runtime;
mod state;
mod tree;

#[cfg(test)]
mod tests;

use bitflags::bitflags;
use core::fmt;
use serde::{Deserialize, Serialize};

pub use crate::Result;
pub use context::Context;
pub use process::{Process, Task};
pub use runtime::Runtime;
pub use state::TaskState;

#[allow(unused_imports)]
pub use tree::{Node, NodeContent, NodeData, NodeKind, NodeTree};

pub enum NextAction {
    Continue,
    Parent,
    Stop,
}

bitflags! {
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
    pub struct Sign: u32 {
        /// Error sign
        const ERROR  = 0b0000_0000_0000_0001;

        /// Error catch sign
        const CATCH  = 0b0000_0000_0000_0010;

        /// Timeout timeout sign
        const TIMEOUT  = 0b0000_0000_0000_0100;

        /// NOT emit message to client
        const NO_EMIT = 0b0000_0000_0000_1000;

        /// Run into children nodes (steps, branches, act)
        const IN_CHILDREN  = 0b0000_0000_0001_0000;

        /// NOT auto complete the task state
        const NO_AUTO_COMPLETE  = 0b0000_0000_0010_0000;

        /// uses action completed
        const USES_COMPLETE  = 0b0000_0000_0100_0000;

        /// task `next` propagation completed (durable replay guard: persisted
        /// before the outbox record is closed, so recovery skips completed work)
        const NEXT_COMPLETE  = 0b0000_0000_1000_0000;
    }
}

pub trait ActTask: Clone + Send {
    async fn init(&self, _ctx: &Context) -> Result<()> {
        Ok(())
    }

    async fn run(&self, _ctx: &Context) -> Result<()> {
        Ok(())
    }

    async fn next(&self, _ctx: &Context) -> Result<NextAction> {
        Ok(NextAction::Parent)
    }

    async fn on_error(&self, ctx: &Context) -> Result<()> {
        ctx.emit_error().await
    }

    async fn on_timeout(&self, _ctx: &Context) -> Result<()> {
        Ok(())
    }
}

impl fmt::Display for NextAction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            NextAction::Continue => write!(f, "continue"),
            NextAction::Parent => write!(f, "parent"),
            NextAction::Stop => write!(f, "stop"),
        }
    }
}

impl NextAction {
    #[allow(dead_code)]
    pub fn is_continue(&self) -> bool {
        matches!(self, NextAction::Continue)
    }

    pub fn is_parent(&self) -> bool {
        matches!(self, NextAction::Parent)
    }
}