yao 0.1.4

a fast, tiny, 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

mod cache;
mod consts;
mod context;
mod event;
mod proc;
mod queue;
mod scheduler;
mod state;

#[cfg(test)]
mod tests;

use crate::{Act, Engine, Job, Step, Workflow};
use async_trait::async_trait;
use core::clone::Clone;
use std::sync::Arc;

pub use context::Context;
pub use event::{Event, EventAction, EventData, Message, UserData};
pub use proc::{Matcher, Proc, Task};
pub use scheduler::Scheduler;
pub use state::TaskState;

#[async_trait]
pub trait ActTask: Clone + Send {
    fn prepare(&self, _ctx: &Context) {}
    fn run(&self, ctx: &Context);
    fn post(&self, _ctx: &Context) {}
}

pub trait ActId: Clone {
    fn tid(&self) -> String;
}

pub trait ActState: Clone + Send {
    fn set_state(&self, state: &TaskState);
    fn state(&self) -> TaskState;
}

pub trait ActTime: Clone + Send {
    fn get_state_time(&self) -> u64;
    fn get_end_time(&self) -> u64;
}

impl Engine {
    pub fn on_workflow_start(&self, f: impl Fn(&Workflow) + Send + Sync + 'static) {
        let evt = Event::OnStart(Arc::new(f));
        self.register_event(&evt);
    }

    pub fn on_workflow_complete(&self, f: impl Fn(&Workflow) + Send + Sync + 'static) {
        let evt = Event::OnComplete(Arc::new(f));
        self.register_event(&evt);
    }

    ///  Receive act message
    ///
    /// Example
    /// ```rust
    /// use yao::{Engine, Workflow, Vars, Message};
    ///
    /// #[tokio::main]
    /// async fn main() {
    ///     let engine = Engine::new();
    ///     let workflow = Workflow::new().with_job(|job| {
    ///         job.with_step(|step| {
    ///             step.with_subject(|sub| sub.with_matcher("any").with_users(r#"["a"]"#))
    ///         })
    ///     });
    ///     println!("{}", workflow.to_string().unwrap());
    ///     let e = engine.clone();
    ///     engine.on_message(move |msg: &Message| {
    ///         e.close();
    ///         assert_eq!(msg.user, "a");
    ///     });
    ///     engine.push(&workflow);
    ///     engine.start().await;
    /// }
    /// ```
    pub fn on_message(&self, f: impl Fn(&Message) + Send + Sync + 'static) {
        let evt = Event::OnMessage(Arc::new(f));
        self.register_event(&evt);
    }

    pub fn on_job(&self, f: impl Fn(&Job) + Send + Sync + 'static) {
        let evt = Event::OnJob(Arc::new(f));
        self.register_event(&evt);
    }

    pub fn on_step(&self, f: impl Fn(&Step) + Send + Sync + 'static) {
        let evt = Event::OnStep(Arc::new(f));
        self.register_event(&evt);
    }

    pub fn on_act(&self, f: impl Fn(&Act) + Send + Sync + 'static) {
        let evt = Event::OnAct(Arc::new(f));
        self.register_event(&evt);
    }
}