cronback_api_model/
run.rs

1use chrono::{DateTime, Utc};
2#[cfg(feature = "dto")]
3use dto::{FromProto, IntoProto};
4#[cfg(feature = "dto")]
5use lib::types::RunId;
6use serde::{Deserialize, Serialize};
7use serde_with::{serde_as, skip_serializing_none};
8use strum::Display;
9
10use super::{Action, Attempt, Payload};
11#[cfg(not(feature = "dto"))]
12use crate::RunId;
13
14#[cfg_attr(feature = "client", non_exhaustive)]
15#[derive(
16    Debug, Display, Deserialize, PartialEq, Serialize, Clone, Copy, Default,
17)]
18#[cfg_attr(
19    feature = "dto",
20    derive(IntoProto),
21    proto(target = "proto::scheduler_proto::RunMode")
22)]
23#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
24#[cfg_attr(feature = "clap", clap(rename_all = "snake_case"))]
25#[serde(rename_all = "snake_case")]
26#[strum(serialize_all = "snake_case")]
27pub enum RunMode {
28    Sync,
29    #[default]
30    Async,
31}
32
33#[derive(Debug, Display, Clone, Copy, Serialize, Deserialize, PartialEq)]
34#[cfg_attr(feature = "client", non_exhaustive)]
35#[cfg_attr(
36    feature = "dto",
37    derive(FromProto),
38    proto(target = "proto::run_proto::RunStatus")
39)]
40#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
41#[cfg_attr(feature = "clap", clap(rename_all = "snake_case"))]
42#[serde(rename_all = "snake_case")]
43#[strum(serialize_all = "snake_case")]
44pub enum RunStatus {
45    Attempting,
46    Succeeded,
47    Failed,
48}
49
50#[skip_serializing_none]
51#[derive(Debug, Clone, Serialize, Deserialize)]
52#[cfg_attr(
53    feature = "server",
54    derive(Default),
55    serde(default),
56    serde(deny_unknown_fields)
57)]
58pub struct RunTrigger {
59    pub mode: RunMode,
60}
61
62#[serde_as]
63#[skip_serializing_none]
64#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
65#[cfg_attr(
66    feature = "dto",
67    derive(FromProto),
68    proto(target = "proto::run_proto::Run")
69)]
70#[cfg_attr(feature = "server", serde(deny_unknown_fields))]
71pub struct Run {
72    #[cfg_attr(feature = "dto", proto(required))]
73    pub id: RunId,
74    #[cfg_attr(feature = "dto", proto(required))]
75    pub created_at: DateTime<Utc>,
76    pub payload: Option<Payload>,
77    #[cfg_attr(feature = "dto", proto(required))]
78    pub action: Action,
79    pub status: RunStatus,
80    pub latest_attempt: Option<Attempt>,
81}
82
83#[derive(Debug, Serialize, Deserialize, Clone)]
84#[cfg_attr(
85    feature = "dto",
86    derive(FromProto),
87    proto(target = "proto::dispatcher_proto::GetRunResponse")
88)]
89pub struct GetRunResponse {
90    #[serde(flatten)]
91    #[cfg_attr(feature = "dto", proto(required))]
92    pub run: Run,
93}
94
95#[cfg(test)]
96mod test {
97    use super::{RunMode, RunStatus};
98
99    #[test]
100    fn run_mode_to_string() {
101        assert_eq!(RunMode::Sync.to_string(), "sync");
102        assert_eq!(RunMode::Async.to_string(), "async");
103    }
104
105    #[test]
106    fn run_status_to_string() {
107        assert_eq!(RunStatus::Attempting.to_string(), "attempting");
108        assert_eq!(RunStatus::Succeeded.to_string(), "succeeded");
109        assert_eq!(RunStatus::Failed.to_string(), "failed");
110    }
111}