1use crate::{
2 scheduler::{self, NodeData},
3 store::data,
4 ActError, MessageState, Result, Workflow,
5};
6use serde::{Deserialize, Serialize};
7use std::sync::Arc;
8
9#[derive(Debug, Deserialize, Serialize, Clone)]
10pub struct PackageInfo {
11 pub id: String,
12 pub name: String,
13 pub size: u32,
14 pub create_time: i64,
15 pub update_time: i64,
16 pub timestamp: i64,
17 pub data: String,
18}
19
20#[derive(Debug, Deserialize, Serialize, Clone)]
21pub struct ProcInfo {
22 pub id: String,
23 pub name: String,
24 pub mid: String,
25 pub state: String,
26 pub start_time: i64,
27 pub end_time: i64,
28 pub timestamp: i64,
29 pub tasks: Vec<TaskInfo>,
30}
31
32#[derive(Debug, Deserialize, Serialize, Clone)]
33pub struct TaskInfo {
34 pub id: String,
35 pub prev: Option<String>,
36 pub name: String,
37 pub tag: String,
38 pub key: String,
39 pub pid: String,
40 pub nid: String,
41 pub r#type: String,
42 pub state: String,
43 pub data: String,
44 pub start_time: i64,
45 pub end_time: i64,
46 pub timestamp: i64,
47}
48
49#[derive(Debug, Deserialize, Serialize, Clone)]
50pub struct ModelInfo {
51 pub id: String,
52 pub name: String,
53 pub ver: u32,
54 pub size: u32,
55 pub create_time: i64,
56 pub update_time: i64,
57 pub data: String,
58}
59
60#[derive(Debug, Deserialize, Serialize, Clone)]
61pub struct MessageInfo {
62 pub id: String,
63 pub tid: String,
64 pub name: String,
65 pub state: MessageState,
66 pub r#type: String,
67 pub pid: String,
68 pub nid: String,
69 pub key: String,
70 pub inputs: String,
71 pub outputs: String,
72 pub tag: String,
73 pub create_time: i64,
74 pub update_time: i64,
75 pub retry_times: i32,
76 pub status: String,
77 pub timestamp: i64,
78}
79
80impl From<&data::Package> for PackageInfo {
81 fn from(m: &data::Package) -> Self {
82 Self {
83 id: m.id.clone(),
84 name: m.name.clone(),
85 size: m.size,
86 timestamp: m.timestamp,
87 create_time: m.create_time,
88 update_time: m.update_time,
89 data: String::from_utf8(m.data.clone()).unwrap(),
90 }
91 }
92}
93
94impl ModelInfo {
95 pub fn workflow(&self) -> Result<Workflow> {
96 let m = serde_yaml::from_str::<Workflow>(&self.data);
97 match m {
98 Ok(mut m) => {
99 m.set_ver(self.ver);
100 Ok(m)
101 }
102 Err(err) => Err(ActError::Convert(err.to_string())),
103 }
104 }
105}
106
107impl From<data::Model> for ModelInfo {
108 fn from(m: data::Model) -> Self {
109 Self {
110 id: m.id,
111 name: m.name,
112 ver: m.ver,
113 size: m.size,
114 create_time: m.create_time,
115 update_time: m.update_time,
116 data: m.data,
117 }
118 }
119}
120
121impl From<&data::Model> for ModelInfo {
122 fn from(m: &data::Model) -> Self {
123 m.clone().into()
124 }
125}
126
127impl From<&data::Proc> for ProcInfo {
128 fn from(p: &data::Proc) -> Self {
129 Self {
130 id: p.id.clone(),
131 name: p.name.clone(),
132 mid: p.mid.clone(),
133 state: p.state.clone(),
134 start_time: p.start_time,
135 end_time: p.end_time,
136 timestamp: p.timestamp,
137 tasks: Vec::new(),
138 }
139 }
140}
141
142impl From<data::Task> for TaskInfo {
143 fn from(t: data::Task) -> Self {
144 let node_data: NodeData = serde_json::from_str(&t.node_data).unwrap();
145 Self {
146 id: t.tid,
147 prev: t.prev,
148 name: t.name,
149 pid: t.pid,
150 nid: node_data.id,
151 r#type: t.kind,
152 state: t.state,
153 data: t.data,
154 start_time: t.start_time,
155 end_time: t.end_time,
156 timestamp: t.timestamp,
157 key: node_data.content.key(),
158 tag: node_data.content.tag(),
159 }
160 }
161}
162
163impl From<&data::Task> for TaskInfo {
164 fn from(t: &data::Task) -> Self {
165 t.clone().into()
166 }
167}
168
169impl From<&Arc<scheduler::Task>> for TaskInfo {
170 fn from(t: &Arc<scheduler::Task>) -> Self {
171 Self {
172 id: t.id.clone(),
173 prev: t.prev(),
174 name: t.node().content.name(),
175 pid: t.pid.clone(),
176 nid: t.node().id().to_string(),
177 r#type: t.node().typ(),
178 state: t.state().into(),
179 data: t.data().to_string(),
180 start_time: t.start_time(),
181 end_time: t.end_time(),
182 timestamp: t.timestamp,
183 tag: t.node().tag(),
184 key: t.node().key(),
185 }
186 }
187}
188
189impl From<&data::Message> for MessageInfo {
190 fn from(m: &data::Message) -> Self {
191 Self {
192 id: m.id.clone(),
193 name: m.name.clone(),
194 pid: m.pid.clone(),
195 tid: m.tid.clone(),
196 nid: m.nid.clone(),
197 timestamp: m.timestamp,
198 create_time: m.create_time,
199 update_time: m.update_time,
200 state: m.state,
201 r#type: m.r#type.clone(),
202 key: m.key.clone(),
203 tag: m.tag.clone(),
204
205 inputs: m.inputs.clone(),
206 outputs: m.outputs.clone(),
207 retry_times: m.retry_times,
208 status: m.status.to_string(),
209 }
210 }
211}
212
213impl From<PackageInfo> for serde_json::Value {
214 fn from(val: PackageInfo) -> Self {
215 serde_json::to_value(val).unwrap()
216 }
217}
218
219impl From<TaskInfo> for serde_json::Value {
220 fn from(val: TaskInfo) -> Self {
221 serde_json::to_value(val).unwrap()
222 }
223}
224
225impl From<ProcInfo> for serde_json::Value {
226 fn from(val: ProcInfo) -> Self {
227 serde_json::to_value(val).unwrap()
228 }
229}
230
231impl From<ModelInfo> for serde_json::Value {
232 fn from(val: ModelInfo) -> Self {
233 serde_json::to_value(val).unwrap()
234 }
235}
236
237impl From<MessageInfo> for serde_json::Value {
238 fn from(val: MessageInfo) -> Self {
239 serde_json::to_value(val).unwrap()
240 }
241}