acts_channel/model/
message.rs

1use crate::Vars;
2use core::fmt;
3use serde::{Deserialize, Serialize};
4
5#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
6pub enum MessageState {
7    #[default]
8    None,
9    Created,
10    Completed,
11    Submitted,
12    Backed,
13    Cancelled,
14    Aborted,
15    Skipped,
16    Error,
17    Removed,
18}
19
20#[derive(Default, Serialize, Deserialize, Clone, Debug)]
21pub struct Model {
22    /// workflow id
23    pub id: String,
24
25    /// workflow tag
26    pub tag: String,
27
28    /// workflow name
29    pub name: String,
30}
31#[derive(Default, Serialize, Deserialize, Clone, Debug)]
32pub struct Message {
33    /// message id
34    pub id: String,
35
36    /// task id
37    pub tid: String,
38
39    /// node id
40    pub nid: String,
41
42    /// model id
43    pub mid: String,
44
45    /// node name or action name
46    pub name: String,
47
48    /// task action state
49    pub state: String,
50
51    /// message type
52    /// msg | req
53    pub r#type: String,
54
55    // node kind
56    pub source: String,
57
58    pub model: Model,
59
60    /// proc id
61    pub pid: String,
62
63    /// nodeId or specific message key
64    pub key: String,
65
66    /// from the task inputs
67    pub inputs: Vars,
68
69    /// set the outputs vars when complete the action
70    pub outputs: Vars,
71
72    /// tag to distinguish different message
73    /// it is from node tag or group tag
74    pub tag: String,
75
76    /// task start time in million second
77    pub start_time: i64,
78
79    /// task end time in million second
80    pub end_time: i64,
81
82    /// record the message retry times
83    pub retry_times: i32,
84}
85
86impl Message {
87    pub fn state(&self) -> MessageState {
88        let state = self.state.as_str().into();
89        state
90    }
91
92    pub fn is_key(&self, key: &str) -> bool {
93        self.key == key
94    }
95
96    pub fn is_state(&self, state: &str) -> bool {
97        self.state == state
98    }
99
100    pub fn is_type(&self, t: &str) -> bool {
101        self.r#type == t
102    }
103
104    pub fn is_source(&self, t: &str) -> bool {
105        self.source == t
106    }
107
108    pub fn is_tag(&self, tag: &str) -> bool {
109        self.tag == tag
110    }
111
112    pub fn type_of(&self, mtype: &str) -> Option<&Self> {
113        if self.r#type == mtype {
114            return Some(self);
115        }
116        None
117    }
118
119    pub fn tag_of(&self, tag: &str) -> Option<&Self> {
120        if tag == self.tag {
121            return Some(self);
122        }
123
124        None
125    }
126
127    pub fn key_of(&self, key: &str) -> Option<&Self> {
128        if key == self.key {
129            return Some(self);
130        }
131
132        None
133    }
134
135    /// workflow cost in million seconds
136    pub fn cost(&self) -> i64 {
137        let state: MessageState = self.state.as_str().into();
138        if state.is_completed() {
139            return self.end_time - self.start_time;
140        }
141
142        0
143    }
144}
145
146impl MessageState {
147    pub fn is_completed(&self) -> bool {
148        matches!(
149            self,
150            MessageState::Completed
151                | MessageState::Cancelled
152                | MessageState::Submitted
153                | MessageState::Backed
154                | MessageState::Error
155                | MessageState::Skipped
156                | MessageState::Aborted
157                | MessageState::Removed
158        )
159    }
160}
161
162impl fmt::Display for MessageState {
163    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
164        let s: String = self.into();
165        f.write_str(&s)
166    }
167}
168
169impl From<&MessageState> for String {
170    fn from(state: &MessageState) -> Self {
171        message_state_to_str(state)
172    }
173}
174
175impl From<&str> for MessageState {
176    fn from(str: &str) -> Self {
177        str_to_message_state(str)
178    }
179}
180
181impl From<String> for MessageState {
182    fn from(str: String) -> Self {
183        str_to_message_state(&str)
184    }
185}
186
187fn message_state_to_str(state: &MessageState) -> String {
188    match state {
189        MessageState::None => "none".to_string(),
190        MessageState::Aborted => "aborted".to_string(),
191        MessageState::Backed => "backed".to_string(),
192        MessageState::Cancelled => "cancelled".to_string(),
193        MessageState::Completed => "completed".to_string(),
194        MessageState::Created => "created".to_string(),
195        MessageState::Skipped => "skipped".to_string(),
196        MessageState::Submitted => "submitted".to_string(),
197        MessageState::Error => "error".to_string(),
198        MessageState::Removed => "removed".to_string(),
199    }
200}
201
202fn str_to_message_state(s: &str) -> MessageState {
203    match s {
204        "aborted" => MessageState::Aborted,
205        "backed" => MessageState::Backed,
206        "cancelled" => MessageState::Cancelled,
207        "completed" => MessageState::Completed,
208        "created" => MessageState::Created,
209        "skipped" => MessageState::Skipped,
210        "submitted" => MessageState::Submitted,
211        "error" => MessageState::Error,
212        "removed" => MessageState::Removed,
213        "none" => MessageState::None,
214        _ => MessageState::None,
215    }
216}
acts_channel/model/message.rs

acts_channel/model/
message.rs
