1use std::time::SystemTime;
2
3use crate::{
4 job_definition::{JobDefinition, RetryPolicy, TimeoutBaseTime, TimeoutPolicy},
5 schedule_definition::{
6 ScheduleDefinition, ScheduleDetails, ScheduleJobCreationPolicy, ScheduleJobTimingPolicy,
7 ScheduleJobTimingPolicyCron, ScheduleJobTimingPolicyRepeat, ScheduleMissedTimePolicy,
8 ScheduleTimeRange,
9 },
10};
11use eyre::OptionExt;
12use ora_proto::{common::v1, server::v1::Schedule};
13
14impl From<v1::JobTimeoutPolicy> for TimeoutPolicy {
15 fn from(policy: v1::JobTimeoutPolicy) -> Self {
16 Self {
17 timeout: policy.timeout.and_then(|d| d.try_into().ok()),
18 base_time: policy.base_time().into(),
19 }
20 }
21}
22
23impl From<TimeoutPolicy> for v1::JobTimeoutPolicy {
24 fn from(policy: TimeoutPolicy) -> Self {
25 Self {
26 timeout: policy.timeout.and_then(|v| v.try_into().ok()),
27 base_time: v1::JobTimeoutBaseTime::from(policy.base_time).into(),
28 }
29 }
30}
31
32impl From<v1::JobTimeoutBaseTime> for TimeoutBaseTime {
33 fn from(base_time: v1::JobTimeoutBaseTime) -> Self {
34 match base_time {
35 v1::JobTimeoutBaseTime::Unspecified | v1::JobTimeoutBaseTime::StartTime => {
36 Self::StartTime
37 }
38 v1::JobTimeoutBaseTime::TargetExecutionTime => Self::TargetExecutionTime,
39 }
40 }
41}
42
43impl From<TimeoutBaseTime> for v1::JobTimeoutBaseTime {
44 fn from(base_time: TimeoutBaseTime) -> Self {
45 match base_time {
46 TimeoutBaseTime::StartTime => v1::JobTimeoutBaseTime::StartTime,
47 TimeoutBaseTime::TargetExecutionTime => v1::JobTimeoutBaseTime::TargetExecutionTime,
48 }
49 }
50}
51
52impl From<v1::JobRetryPolicy> for RetryPolicy {
53 fn from(policy: v1::JobRetryPolicy) -> Self {
54 Self {
55 retries: policy.retries,
56 }
57 }
58}
59
60impl From<RetryPolicy> for v1::JobRetryPolicy {
61 fn from(policy: RetryPolicy) -> Self {
62 Self {
63 retries: policy.retries,
64 }
65 }
66}
67
68impl From<JobDefinition> for v1::JobDefinition {
69 fn from(definition: JobDefinition) -> Self {
70 Self {
71 job_type_id: definition.job_type_id.into(),
72 target_execution_time: Some(definition.target_execution_time.into()),
73 input_payload_json: definition.input_payload_json,
74 labels: definition
75 .labels
76 .into_iter()
77 .map(|(key, value)| v1::JobLabel { key, value })
78 .collect(),
79 timeout_policy: Some(definition.timeout_policy.into()),
80 retry_policy: Some(definition.retry_policy.into()),
81 metadata_json: definition.metadata_json,
82 }
83 }
84}
85
86impl From<v1::JobDefinition> for JobDefinition {
87 fn from(definition: v1::JobDefinition) -> Self {
88 Self {
89 job_type_id: definition.job_type_id.into(),
90 target_execution_time: definition
91 .target_execution_time
92 .and_then(|t| SystemTime::try_from(t).ok())
93 .unwrap_or(SystemTime::UNIX_EPOCH),
94 input_payload_json: definition.input_payload_json,
95 labels: definition
96 .labels
97 .into_iter()
98 .map(|label| (label.key, label.value))
99 .collect(),
100 timeout_policy: definition.timeout_policy.unwrap_or_default().into(),
101 retry_policy: definition.retry_policy.unwrap_or_default().into(),
102 metadata_json: definition.metadata_json,
103 }
104 }
105}
106
107impl From<ScheduleDefinition> for v1::ScheduleDefinition {
108 fn from(definition: ScheduleDefinition) -> Self {
109 Self {
110 job_timing_policy: Some(definition.job_timing_policy.into()),
111 job_creation_policy: Some(match definition.job_creation_policy {
112 ScheduleJobCreationPolicy::JobDefinition(job_definition) => {
113 v1::ScheduleJobCreationPolicy {
114 job_creation: Some(
115 v1::schedule_job_creation_policy::JobCreation::JobDefinition(
116 job_definition.into(),
117 ),
118 ),
119 }
120 }
121 }),
122 labels: definition
123 .labels
124 .into_iter()
125 .map(|(key, value)| v1::ScheduleLabel { key, value })
126 .collect(),
127 time_range: definition.time_range.map(Into::into),
128 metadata_json: definition.metadata_json,
129 }
130 }
131}
132
133impl From<v1::TimeRange> for ScheduleTimeRange {
134 fn from(time_range: v1::TimeRange) -> Self {
135 Self {
136 start: time_range
137 .start
138 .and_then(|start_time| start_time.try_into().ok()),
139 end: time_range.end.and_then(|end_time| end_time.try_into().ok()),
140 }
141 }
142}
143
144impl From<ScheduleTimeRange> for v1::TimeRange {
145 fn from(time_range: ScheduleTimeRange) -> Self {
146 Self {
147 start: time_range.start.map(Into::into),
148 end: time_range.end.map(Into::into),
149 }
150 }
151}
152
153impl From<ScheduleJobTimingPolicy> for v1::ScheduleJobTimingPolicy {
154 fn from(policy: ScheduleJobTimingPolicy) -> Self {
155 match policy {
156 ScheduleJobTimingPolicy::Repeat(scheduling_policy_repeat) => {
157 v1::ScheduleJobTimingPolicy {
158 job_timing: Some(v1::schedule_job_timing_policy::JobTiming::Repeat(
159 v1::ScheduleJobTimingPolicyRepeat {
160 interval: Some(scheduling_policy_repeat.interval.try_into().unwrap()),
161 immediate: scheduling_policy_repeat.immediate,
162 missed_time_policy: v1::ScheduleMissedTimePolicy::from(
163 scheduling_policy_repeat.missed_time_policy,
164 )
165 .into(),
166 },
167 )),
168 }
169 }
170 ScheduleJobTimingPolicy::Cron(scheduling_policy_cron) => v1::ScheduleJobTimingPolicy {
171 job_timing: Some(v1::schedule_job_timing_policy::JobTiming::Cron(
172 v1::ScheduleJobTimingPolicyCron {
173 cron_expression: scheduling_policy_cron.cron_expression,
174 immediate: scheduling_policy_cron.immediate,
175 missed_time_policy: v1::ScheduleMissedTimePolicy::from(
176 scheduling_policy_cron.missed_time_policy,
177 )
178 .into(),
179 },
180 )),
181 },
182 }
183 }
184}
185
186impl TryFrom<v1::ScheduleJobTimingPolicy> for ScheduleJobTimingPolicy {
187 type Error = eyre::Report;
188
189 fn try_from(policy: v1::ScheduleJobTimingPolicy) -> eyre::Result<Self> {
190 Ok(match policy.job_timing.ok_or_eyre("missing job timing")? {
191 v1::schedule_job_timing_policy::JobTiming::Repeat(scheduling_policy_repeat) => {
192 ScheduleJobTimingPolicy::Repeat(ScheduleJobTimingPolicyRepeat {
193 missed_time_policy: scheduling_policy_repeat.missed_time_policy().into(),
194 interval: scheduling_policy_repeat
195 .interval
196 .ok_or_eyre("missing schedule policy interval")?
197 .try_into()?,
198 immediate: scheduling_policy_repeat.immediate,
199 })
200 }
201 v1::schedule_job_timing_policy::JobTiming::Cron(scheduling_policy_cron) => {
202 ScheduleJobTimingPolicy::Cron(ScheduleJobTimingPolicyCron {
203 missed_time_policy: scheduling_policy_cron.missed_time_policy().into(),
204 cron_expression: scheduling_policy_cron.cron_expression,
205 immediate: scheduling_policy_cron.immediate,
206 })
207 }
208 })
209 }
210}
211
212impl From<ScheduleMissedTimePolicy> for v1::ScheduleMissedTimePolicy {
213 fn from(policy: ScheduleMissedTimePolicy) -> Self {
214 match policy {
215 ScheduleMissedTimePolicy::Skip => Self::Skip,
216 ScheduleMissedTimePolicy::Create => Self::Create,
217 }
218 }
219}
220
221impl From<v1::ScheduleMissedTimePolicy> for ScheduleMissedTimePolicy {
222 fn from(policy: v1::ScheduleMissedTimePolicy) -> Self {
223 match policy {
224 v1::ScheduleMissedTimePolicy::Skip | v1::ScheduleMissedTimePolicy::Unspecified => {
225 Self::Skip
226 }
227 v1::ScheduleMissedTimePolicy::Create => Self::Create,
228 }
229 }
230}
231
232impl From<ScheduleJobCreationPolicy> for v1::ScheduleJobCreationPolicy {
233 fn from(policy: ScheduleJobCreationPolicy) -> Self {
234 match policy {
235 ScheduleJobCreationPolicy::JobDefinition(job_definition) => Self {
236 job_creation: Some(
237 v1::schedule_job_creation_policy::JobCreation::JobDefinition(
238 job_definition.into(),
239 ),
240 ),
241 },
242 }
243 }
244}
245
246impl TryFrom<v1::ScheduleJobCreationPolicy> for ScheduleJobCreationPolicy {
247 type Error = eyre::Report;
248
249 fn try_from(policy: v1::ScheduleJobCreationPolicy) -> eyre::Result<Self> {
250 Ok(
251 match policy.job_creation.ok_or_eyre("missing job creation")? {
252 v1::schedule_job_creation_policy::JobCreation::JobDefinition(job_definition) => {
253 ScheduleJobCreationPolicy::JobDefinition(job_definition.into())
254 }
255 },
256 )
257 }
258}
259
260impl TryFrom<Schedule> for ScheduleDetails {
261 type Error = eyre::Report;
262
263 fn try_from(schedule: Schedule) -> eyre::Result<Self> {
264 let schedule_definition = schedule
265 .definition
266 .ok_or_eyre("missing schedule definition")?;
267
268 Ok(Self {
269 id: schedule.id.parse()?,
270 created_at: SystemTime::try_from(
271 schedule.created_at.ok_or_eyre("missing created_at")?,
272 )?,
273 cancelled: schedule.cancelled,
274 active: schedule.active,
275 job_timing_policy: schedule_definition
276 .job_timing_policy
277 .ok_or_eyre("missing job timing policy")?
278 .try_into()?,
279 job_creation_policy: schedule_definition
280 .job_creation_policy
281 .ok_or_eyre("missing job creation policy")?
282 .try_into()?,
283 labels: schedule_definition
284 .labels
285 .into_iter()
286 .map(|label| (label.key, label.value))
287 .collect(),
288 time_range: schedule_definition.time_range.map(Into::into),
289 metadata_json: schedule_definition.metadata_json,
290 })
291 }
292}