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

use crate::TaskState;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, PartialEq, Clone)]
pub enum Tag {
    Workflow,
    Job,
    Branch,
    Step,
    Act,
}

#[derive(Deserialize, Serialize, Clone)]
pub struct Task {
    pub id: String,
    pub tag: Tag,
    pub pid: String,
    pub tid: String,
    pub state: TaskState,
    pub start_time: i64,
    pub end_time: i64,
    pub user: String,
}

impl<'a> From<Tag> for &'a str {
    fn from(tag: Tag) -> Self {
        let s = match tag {
            Tag::Workflow => "w",
            Tag::Job => "j",
            Tag::Branch => "b",
            Tag::Step => "s",
            Tag::Act => "a",
        };

        s
    }
}

impl From<&str> for Tag {
    fn from(str: &str) -> Self {
        let s = match str {
            "w" => Tag::Workflow,
            "j" => Tag::Job,
            "b" => Tag::Branch,
            "s" => Tag::Step,
            "a" => Tag::Act,
            _ => panic!("not found tag: {}", str),
        };

        s
    }
}

impl Task {
    pub fn set_state(&mut self, state: TaskState) {
        self.state = state;
    }
    pub fn set_start_time(&mut self, time: i64) {
        self.start_time = time;
    }
    pub fn set_end_time(&mut self, time: i64) {
        self.end_time = time;
    }
    pub fn set_user(&mut self, user: &str) {
        self.user = user.to_string();
    }
}