1use crate::{
2 models::{
3 server_backup::ServerBackupKind, system_backup_policy::SystemBackupPolicy,
4 system_backup_policy_run_target::SystemBackupPolicyRunTargetReason,
5 },
6 prelude::*,
7};
8use serde::{Deserialize, Serialize};
9use sqlx::{Row, postgres::PgRow};
10use std::{collections::BTreeMap, sync::LazyLock};
11
12const PROGRESS_JOIN: &str = r#"
13 LEFT JOIN LATERAL (
14 SELECT
15 COUNT(*) FILTER (
16 WHERE system_backup_policy_run_targets.status = 'PENDING'
17 ) AS pending_targets,
18 COUNT(*) FILTER (
19 WHERE system_backup_policy_run_targets.status = 'DISPATCHED'
20 AND COALESCE(
21 server_backups.completed IS NULL
22 AND server_backups.deleted IS NULL
23 AND server_backups.created >= NOW() - INTERVAL '1 day',
24 FALSE
25 )
26 ) AS running_targets,
27 COUNT(*) FILTER (
28 WHERE system_backup_policy_run_targets.status = 'DISPATCHED'
29 AND server_backups.successful
30 ) AS successful_targets,
31 COUNT(*) FILTER (
32 WHERE system_backup_policy_run_targets.status = 'FAILED'
33 OR (
34 system_backup_policy_run_targets.status = 'DISPATCHED'
35 AND NOT COALESCE(server_backups.successful, FALSE)
36 AND NOT COALESCE(
37 server_backups.completed IS NULL
38 AND server_backups.deleted IS NULL
39 AND server_backups.created >= NOW() - INTERVAL '1 day',
40 FALSE
41 )
42 )
43 ) AS failed_targets,
44 COUNT(*) FILTER (
45 WHERE system_backup_policy_run_targets.status = 'SKIPPED'
46 ) AS skipped_targets
47 FROM system_backup_policy_run_targets
48 LEFT JOIN server_backups ON server_backups.uuid = system_backup_policy_run_targets.server_backup_uuid
49 WHERE
50 system_backup_policy_run_targets.system_backup_policy_run_uuid = system_backup_policy_runs.uuid
51 AND system_backup_policy_runs.completed IS NULL
52 ) AS system_backup_policy_run_progress ON TRUE
53"#;
54
55#[derive(Serialize, Deserialize, Clone)]
56pub struct SystemBackupPolicyRun {
57 pub uuid: uuid::Uuid,
58 pub system_backup_policy: Fetchable<SystemBackupPolicy>,
59
60 pub manual: bool,
61 pub occurrence: chrono::NaiveDateTime,
62
63 pub total_targets: i64,
64 pub pending_targets: i64,
65 pub running_targets: i64,
66 pub successful_targets: i64,
67 pub failed_targets: i64,
68 pub skipped_targets: i64,
69
70 pub cancelled: Option<chrono::NaiveDateTime>,
71 pub completed: Option<chrono::NaiveDateTime>,
72 pub created: chrono::NaiveDateTime,
73
74 extension_data: super::ModelExtensionData,
75}
76
77impl BaseModel for SystemBackupPolicyRun {
78 const NAME: &'static str = "system_backup_policy_run";
79
80 fn get_extension_list() -> &'static super::ModelExtensionList {
81 static EXTENSIONS: LazyLock<super::ModelExtensionList> =
82 LazyLock::new(|| parking_lot::RwLock::new(Vec::new()));
83
84 &EXTENSIONS
85 }
86
87 fn get_extension_data(&self) -> &super::ModelExtensionData {
88 &self.extension_data
89 }
90
91 #[inline]
92 fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, compact_str::CompactString> {
93 let prefix = prefix.unwrap_or_default();
94
95 BTreeMap::from([
96 (
97 "system_backup_policy_runs.uuid",
98 compact_str::format_compact!("{prefix}uuid"),
99 ),
100 (
101 "system_backup_policy_runs.system_backup_policy_uuid",
102 compact_str::format_compact!("{prefix}system_backup_policy_uuid"),
103 ),
104 (
105 "system_backup_policy_runs.manual",
106 compact_str::format_compact!("{prefix}manual"),
107 ),
108 (
109 "system_backup_policy_runs.occurrence",
110 compact_str::format_compact!("{prefix}occurrence"),
111 ),
112 (
113 "system_backup_policy_runs.total_targets::int8",
114 compact_str::format_compact!("{prefix}total_targets"),
115 ),
116 (
117 "COALESCE(system_backup_policy_run_progress.pending_targets, 0)",
118 compact_str::format_compact!("{prefix}pending_targets"),
119 ),
120 (
121 "COALESCE(system_backup_policy_run_progress.running_targets, 0)",
122 compact_str::format_compact!("{prefix}running_targets"),
123 ),
124 (
125 "CASE WHEN system_backup_policy_runs.completed IS NULL THEN system_backup_policy_run_progress.successful_targets ELSE system_backup_policy_runs.successful_targets END",
126 compact_str::format_compact!("{prefix}successful_targets"),
127 ),
128 (
129 "CASE WHEN system_backup_policy_runs.completed IS NULL THEN system_backup_policy_run_progress.failed_targets ELSE system_backup_policy_runs.failed_targets END",
130 compact_str::format_compact!("{prefix}failed_targets"),
131 ),
132 (
133 "CASE WHEN system_backup_policy_runs.completed IS NULL THEN system_backup_policy_run_progress.skipped_targets ELSE system_backup_policy_runs.skipped_targets END",
134 compact_str::format_compact!("{prefix}skipped_targets"),
135 ),
136 (
137 "system_backup_policy_runs.cancelled",
138 compact_str::format_compact!("{prefix}cancelled"),
139 ),
140 (
141 "system_backup_policy_runs.completed",
142 compact_str::format_compact!("{prefix}completed"),
143 ),
144 (
145 "system_backup_policy_runs.created",
146 compact_str::format_compact!("{prefix}created"),
147 ),
148 ])
149 }
150
151 #[inline]
152 fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, crate::database::DatabaseError> {
153 let prefix = prefix.unwrap_or_default();
154
155 Ok(Self {
156 uuid: row.try_get(compact_str::format_compact!("{prefix}uuid").as_str())?,
157 system_backup_policy: SystemBackupPolicy::get_fetchable(row.try_get(
158 compact_str::format_compact!("{prefix}system_backup_policy_uuid").as_str(),
159 )?),
160 manual: row.try_get(compact_str::format_compact!("{prefix}manual").as_str())?,
161 occurrence: row.try_get(compact_str::format_compact!("{prefix}occurrence").as_str())?,
162 total_targets: row
163 .try_get(compact_str::format_compact!("{prefix}total_targets").as_str())?,
164 pending_targets: row
165 .try_get(compact_str::format_compact!("{prefix}pending_targets").as_str())?,
166 running_targets: row
167 .try_get(compact_str::format_compact!("{prefix}running_targets").as_str())?,
168 successful_targets: row
169 .try_get(compact_str::format_compact!("{prefix}successful_targets").as_str())?,
170 failed_targets: row
171 .try_get(compact_str::format_compact!("{prefix}failed_targets").as_str())?,
172 skipped_targets: row
173 .try_get(compact_str::format_compact!("{prefix}skipped_targets").as_str())?,
174 cancelled: row.try_get(compact_str::format_compact!("{prefix}cancelled").as_str())?,
175 completed: row.try_get(compact_str::format_compact!("{prefix}completed").as_str())?,
176 created: row.try_get(compact_str::format_compact!("{prefix}created").as_str())?,
177 extension_data: Self::map_extensions(prefix, row)?,
178 })
179 }
180}
181
182impl SystemBackupPolicyRun {
183 pub async fn by_system_backup_policy_uuid_with_pagination(
184 database: &crate::database::Database,
185 system_backup_policy_uuid: uuid::Uuid,
186 page: i64,
187 per_page: i64,
188 ) -> Result<super::Pagination<Self>, crate::database::DatabaseError> {
189 super::PaginatedQueryBuilder::new(
190 Self::columns_sql(None),
191 format!(
192 r#"
193 FROM system_backup_policy_runs
194 {PROGRESS_JOIN}
195 WHERE system_backup_policy_runs.system_backup_policy_uuid = $1
196 "#
197 ),
198 "system_backup_policy_runs.created DESC, system_backup_policy_runs.uuid DESC",
199 )
200 .bind(system_backup_policy_uuid)
201 .fetch(database, page, per_page)
202 .await
203 }
204
205 pub async fn by_system_backup_policy_uuid_uuid(
206 database: &crate::database::Database,
207 system_backup_policy_uuid: uuid::Uuid,
208 uuid: uuid::Uuid,
209 ) -> Result<Option<Self>, crate::database::DatabaseError> {
210 let row = sqlx::query(sqlx::AssertSqlSafe(format!(
211 r#"
212 SELECT {}
213 FROM system_backup_policy_runs
214 {PROGRESS_JOIN}
215 WHERE
216 system_backup_policy_runs.system_backup_policy_uuid = $1
217 AND system_backup_policy_runs.uuid = $2
218 "#,
219 Self::columns_sql(None)
220 )))
221 .bind(system_backup_policy_uuid)
222 .bind(uuid)
223 .fetch_optional(database.read())
224 .await?;
225
226 row.try_map(|row| Self::map(None, &row))
227 }
228
229 pub async fn all_latest(
230 database: &crate::database::Database,
231 ) -> Result<Vec<Self>, crate::database::DatabaseError> {
232 let rows = sqlx::query(sqlx::AssertSqlSafe(format!(
233 r#"
234 SELECT {}
235 FROM (
236 SELECT DISTINCT ON (system_backup_policy_runs.system_backup_policy_uuid)
237 system_backup_policy_runs.*
238 FROM system_backup_policy_runs
239 ORDER BY
240 system_backup_policy_runs.system_backup_policy_uuid,
241 system_backup_policy_runs.created DESC,
242 system_backup_policy_runs.uuid DESC
243 ) AS system_backup_policy_runs
244 {PROGRESS_JOIN}
245 "#,
246 Self::columns_sql(None)
247 )))
248 .fetch_all(database.read())
249 .await?;
250
251 rows.into_iter()
252 .map(|row| Self::map(None, &row))
253 .try_collect_vec()
254 }
255
256 pub async fn open_by_system_backup_policy_uuid(
257 database: &crate::database::Database,
258 system_backup_policy_uuid: uuid::Uuid,
259 ) -> Result<Vec<Self>, crate::database::DatabaseError> {
260 let rows = sqlx::query(sqlx::AssertSqlSafe(format!(
261 r#"
262 SELECT {}
263 FROM system_backup_policy_runs
264 {PROGRESS_JOIN}
265 WHERE
266 system_backup_policy_runs.system_backup_policy_uuid = $1
267 AND system_backup_policy_runs.completed IS NULL
268 ORDER BY system_backup_policy_runs.created, system_backup_policy_runs.uuid
269 "#,
270 Self::columns_sql(None)
271 )))
272 .bind(system_backup_policy_uuid)
273 .fetch_all(database.write())
274 .await?;
275
276 rows.into_iter()
277 .map(|row| Self::map(None, &row))
278 .try_collect_vec()
279 }
280
281 pub async fn has_pending_by_system_backup_policy_uuid(
282 database: &crate::database::Database,
283 system_backup_policy_uuid: uuid::Uuid,
284 ) -> Result<bool, sqlx::Error> {
285 let exists = sqlx::query_scalar!(
286 r#"
287 SELECT EXISTS (
288 SELECT 1
289 FROM system_backup_policy_run_targets
290 JOIN system_backup_policy_runs ON system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
291 WHERE
292 system_backup_policy_runs.system_backup_policy_uuid = $1
293 AND system_backup_policy_runs.completed IS NULL
294 AND system_backup_policy_run_targets.status = 'PENDING'
295 ) AS "exists!"
296 "#,
297 system_backup_policy_uuid,
298 )
299 .fetch_one(database.write())
300 .await?;
301
302 Ok(exists)
303 }
304
305 pub async fn create(
306 database: &crate::database::Database,
307 policy: &SystemBackupPolicy,
308 manual: bool,
309 occurrence: chrono::NaiveDateTime,
310 ) -> Result<Option<uuid::Uuid>, sqlx::Error> {
311 let mut transaction = database.write().begin().await?;
312
313 let run_uuid = sqlx::query_scalar!(
314 r#"
315 INSERT INTO system_backup_policy_runs (system_backup_policy_uuid, manual, occurrence)
316 SELECT $1, $2, $3
317 WHERE $2 OR NOT EXISTS (
318 SELECT 1
319 FROM system_backup_policy_runs
320 WHERE
321 system_backup_policy_runs.system_backup_policy_uuid = $1
322 AND NOT system_backup_policy_runs.manual
323 AND system_backup_policy_runs.occurrence >= $3
324 )
325 ON CONFLICT DO NOTHING
326 RETURNING system_backup_policy_runs.uuid
327 "#,
328 policy.uuid,
329 manual,
330 occurrence,
331 )
332 .fetch_optional(&mut *transaction)
333 .await?;
334
335 let Some(run_uuid) = run_uuid else {
336 return Ok(None);
337 };
338
339 sqlx::query!(
340 r#"
341 UPDATE system_backup_policy_run_targets
342 SET
343 status = 'SKIPPED',
344 reason = COALESCE(system_backup_policy_run_targets.reason, 'SUPERSEDED'),
345 updated = NOW()
346 FROM system_backup_policy_runs
347 WHERE
348 system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
349 AND system_backup_policy_runs.system_backup_policy_uuid = $1
350 AND system_backup_policy_runs.uuid != $2
351 AND system_backup_policy_runs.completed IS NULL
352 AND system_backup_policy_run_targets.status = 'PENDING'
353 "#,
354 policy.uuid,
355 run_uuid,
356 )
357 .execute(&mut *transaction)
358 .await?;
359
360 let total_targets = match policy.kind {
361 ServerBackupKind::Server => {
362 sqlx::query!(
363 r#"
364 INSERT INTO system_backup_policy_run_targets (system_backup_policy_run_uuid, server_uuid, last_attempt)
365 SELECT $2, servers.uuid, attempts.last_attempt
366 FROM servers
367 JOIN nodes ON nodes.uuid = servers.node_uuid
368 LEFT JOIN LATERAL (
369 SELECT MIN(scopes.created) AS attached
370 FROM (
371 SELECT system_backup_policy_nodes.created
372 FROM system_backup_policy_nodes
373 WHERE
374 system_backup_policy_nodes.system_backup_policy_uuid = $1
375 AND system_backup_policy_nodes.node_uuid = servers.node_uuid
376 UNION ALL
377 SELECT system_backup_policy_locations.created
378 FROM system_backup_policy_locations
379 WHERE
380 system_backup_policy_locations.system_backup_policy_uuid = $1
381 AND system_backup_policy_locations.location_uuid = nodes.location_uuid
382 UNION ALL
383 SELECT system_backup_policy_servers.created
384 FROM system_backup_policy_servers
385 WHERE
386 system_backup_policy_servers.system_backup_policy_uuid = $1
387 AND system_backup_policy_servers.server_uuid = servers.uuid
388 ) AS scopes
389 ) AS coverage ON TRUE
390 LEFT JOIN LATERAL (
391 SELECT
392 MAX(server_backups.created) AS last_attempt,
393 BOOL_OR(
394 server_backups.completed IS NULL
395 AND server_backups.deleted IS NULL
396 AND server_backups.created >= NOW() - INTERVAL '1 day'
397 ) AS in_flight
398 FROM server_backups
399 WHERE
400 server_backups.system_backup_policy_uuid = $1
401 AND server_backups.server_uuid = servers.uuid
402 ) AS attempts ON TRUE
403 WHERE
404 coverage.attached IS NOT NULL
405 AND ($3 OR GREATEST(servers.created, coverage.attached) < $4)
406 AND (attempts.last_attempt IS NULL OR attempts.last_attempt < $4)
407 AND NOT COALESCE(attempts.in_flight, FALSE)
408 "#,
409 policy.uuid,
410 run_uuid,
411 manual,
412 occurrence,
413 )
414 .execute(&mut *transaction)
415 .await?
416 .rows_affected()
417 }
418 ServerBackupKind::DatabaseInstance => {
419 sqlx::query!(
420 r#"
421 INSERT INTO system_backup_policy_run_targets (system_backup_policy_run_uuid, server_uuid, database_instance_uuid, last_attempt)
422 SELECT $2, server_database_instances.server_uuid, server_database_instances.uuid, attempts.last_attempt
423 FROM server_database_instances
424 LEFT JOIN LATERAL (
425 SELECT MIN(scopes.created) AS attached
426 FROM (
427 SELECT system_backup_policy_database_agent_hosts.created
428 FROM system_backup_policy_database_agent_hosts
429 WHERE
430 system_backup_policy_database_agent_hosts.system_backup_policy_uuid = $1
431 AND system_backup_policy_database_agent_hosts.database_agent_host_uuid = server_database_instances.database_agent_host_uuid
432 UNION ALL
433 SELECT system_backup_policy_locations.created
434 FROM system_backup_policy_locations
435 JOIN location_database_agent_hosts ON location_database_agent_hosts.location_uuid = system_backup_policy_locations.location_uuid
436 WHERE
437 system_backup_policy_locations.system_backup_policy_uuid = $1
438 AND location_database_agent_hosts.database_agent_host_uuid = server_database_instances.database_agent_host_uuid
439 UNION ALL
440 SELECT system_backup_policy_servers.created
441 FROM system_backup_policy_servers
442 WHERE
443 system_backup_policy_servers.system_backup_policy_uuid = $1
444 AND system_backup_policy_servers.server_uuid = server_database_instances.server_uuid
445 ) AS scopes
446 ) AS coverage ON TRUE
447 LEFT JOIN LATERAL (
448 SELECT
449 MAX(server_backups.created) AS last_attempt,
450 BOOL_OR(
451 server_backups.completed IS NULL
452 AND server_backups.deleted IS NULL
453 AND server_backups.created >= NOW() - INTERVAL '1 day'
454 ) AS in_flight
455 FROM server_backups
456 WHERE
457 server_backups.system_backup_policy_uuid = $1
458 AND server_backups.database_instance_uuid = server_database_instances.uuid
459 ) AS attempts ON TRUE
460 WHERE
461 coverage.attached IS NOT NULL
462 AND ($3 OR GREATEST(server_database_instances.created, coverage.attached) < $4)
463 AND (attempts.last_attempt IS NULL OR attempts.last_attempt < $4)
464 AND NOT COALESCE(attempts.in_flight, FALSE)
465 "#,
466 policy.uuid,
467 run_uuid,
468 manual,
469 occurrence,
470 )
471 .execute(&mut *transaction)
472 .await?
473 .rows_affected()
474 }
475 };
476
477 sqlx::query!(
478 "UPDATE system_backup_policy_runs
479 SET total_targets = $2
480 WHERE system_backup_policy_runs.uuid = $1",
481 run_uuid,
482 total_targets as i32,
483 )
484 .execute(&mut *transaction)
485 .await?;
486
487 transaction.commit().await?;
488
489 Ok(Some(run_uuid))
490 }
491
492 pub async fn skip_pending_scheduled_by_system_backup_policy_uuid(
493 database: &crate::database::Database,
494 system_backup_policy_uuid: uuid::Uuid,
495 reason: SystemBackupPolicyRunTargetReason,
496 ) -> Result<u64, sqlx::Error> {
497 Ok(sqlx::query!(
498 r#"
499 UPDATE system_backup_policy_run_targets
500 SET status = 'SKIPPED', reason = $2, updated = NOW()
501 FROM system_backup_policy_runs
502 WHERE
503 system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
504 AND system_backup_policy_runs.system_backup_policy_uuid = $1
505 AND NOT system_backup_policy_runs.manual
506 AND system_backup_policy_runs.completed IS NULL
507 AND system_backup_policy_run_targets.status = 'PENDING'
508 "#,
509 system_backup_policy_uuid,
510 reason as SystemBackupPolicyRunTargetReason,
511 )
512 .execute(database.write())
513 .await?
514 .rows_affected())
515 }
516
517 pub async fn cancel(
518 database: &crate::database::Database,
519 system_backup_policy_uuid: uuid::Uuid,
520 uuid: uuid::Uuid,
521 ) -> Result<bool, sqlx::Error> {
522 let row = sqlx::query!(
523 r#"
524 WITH cancelled_run AS (
525 UPDATE system_backup_policy_runs
526 SET cancelled = NOW()
527 WHERE
528 system_backup_policy_runs.uuid = $2
529 AND system_backup_policy_runs.system_backup_policy_uuid = $1
530 AND system_backup_policy_runs.completed IS NULL
531 AND system_backup_policy_runs.cancelled IS NULL
532 RETURNING system_backup_policy_runs.uuid
533 ), skipped_targets AS (
534 UPDATE system_backup_policy_run_targets
535 SET status = 'SKIPPED', reason = 'CANCELLED', not_before = NULL, updated = NOW()
536 FROM cancelled_run
537 WHERE
538 system_backup_policy_run_targets.system_backup_policy_run_uuid = cancelled_run.uuid
539 AND system_backup_policy_run_targets.status = 'PENDING'
540 )
541 SELECT uuid FROM cancelled_run
542 "#,
543 system_backup_policy_uuid,
544 uuid,
545 )
546 .fetch_optional(database.write())
547 .await?;
548
549 Ok(row.is_some())
550 }
551
552 pub async fn complete(&self, database: &crate::database::Database) -> Result<(), sqlx::Error> {
553 sqlx::query!(
554 "UPDATE system_backup_policy_runs
555 SET
556 completed = NOW(),
557 successful_targets = $2,
558 failed_targets = $3,
559 skipped_targets = $4
560 WHERE system_backup_policy_runs.uuid = $1 AND system_backup_policy_runs.completed IS NULL",
561 self.uuid,
562 self.successful_targets as i32,
563 self.failed_targets as i32,
564 self.skipped_targets as i32,
565 )
566 .execute(database.write())
567 .await?;
568
569 Ok(())
570 }
571
572 pub async fn prune(
573 database: &crate::database::Database,
574 keep_runs: i64,
575 keep_targets: i64,
576 ) -> Result<u64, sqlx::Error> {
577 sqlx::query!(
578 r#"
579 DELETE FROM system_backup_policy_run_targets
580 USING (
581 SELECT
582 system_backup_policy_runs.uuid,
583 ROW_NUMBER() OVER (
584 PARTITION BY system_backup_policy_runs.system_backup_policy_uuid
585 ORDER BY system_backup_policy_runs.created DESC, system_backup_policy_runs.uuid DESC
586 ) AS position
587 FROM system_backup_policy_runs
588 WHERE system_backup_policy_runs.completed IS NOT NULL
589 ) AS ranked
590 WHERE
591 ranked.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
592 AND ranked.position > $1
593 "#,
594 keep_targets,
595 )
596 .execute(database.write())
597 .await?;
598
599 Ok(sqlx::query!(
600 r#"
601 DELETE FROM system_backup_policy_runs
602 USING (
603 SELECT
604 system_backup_policy_runs.uuid,
605 ROW_NUMBER() OVER (
606 PARTITION BY system_backup_policy_runs.system_backup_policy_uuid
607 ORDER BY system_backup_policy_runs.created DESC, system_backup_policy_runs.uuid DESC
608 ) AS position
609 FROM system_backup_policy_runs
610 WHERE system_backup_policy_runs.completed IS NOT NULL
611 ) AS ranked
612 WHERE
613 ranked.uuid = system_backup_policy_runs.uuid
614 AND ranked.position > $1
615 "#,
616 keep_runs,
617 )
618 .execute(database.write())
619 .await?
620 .rows_affected())
621 }
622}
623
624#[async_trait::async_trait]
625impl IntoAdminApiObject for SystemBackupPolicyRun {
626 type AdminApiObject = AdminApiSystemBackupPolicyRun;
627 type ExtraArgs<'a> = ();
628
629 async fn into_admin_api_object<'a>(
630 self,
631 state: &crate::State,
632 _args: Self::ExtraArgs<'a>,
633 ) -> Result<Self::AdminApiObject, crate::database::DatabaseError> {
634 let api_object = AdminApiSystemBackupPolicyRun::init_hooks(&self, state).await?;
635
636 let api_object = finish_extendible!(
637 AdminApiSystemBackupPolicyRun {
638 uuid: self.uuid,
639 manual: self.manual,
640 occurrence: self.occurrence.and_utc(),
641 total_targets: self.total_targets,
642 pending_targets: self.pending_targets,
643 running_targets: self.running_targets,
644 successful_targets: self.successful_targets,
645 failed_targets: self.failed_targets,
646 skipped_targets: self.skipped_targets,
647 cancelled: self.cancelled.map(|dt| dt.and_utc()),
648 completed: self.completed.map(|dt| dt.and_utc()),
649 created: self.created.and_utc(),
650 },
651 api_object,
652 state
653 )?;
654
655 Ok(api_object)
656 }
657}
658
659#[schema_extension_derive::extendible]
660#[init_args(SystemBackupPolicyRun, crate::State)]
661#[hook_args(crate::State)]
662#[derive(ToSchema, Serialize)]
663#[schema(title = "SystemBackupPolicyRun")]
664pub struct AdminApiSystemBackupPolicyRun {
665 pub uuid: uuid::Uuid,
666
667 pub manual: bool,
668 pub occurrence: chrono::DateTime<chrono::Utc>,
669
670 pub total_targets: i64,
671 pub pending_targets: i64,
672 pub running_targets: i64,
673 pub successful_targets: i64,
674 pub failed_targets: i64,
675 pub skipped_targets: i64,
676
677 pub cancelled: Option<chrono::DateTime<chrono::Utc>>,
678 pub completed: Option<chrono::DateTime<chrono::Utc>>,
679 pub created: chrono::DateTime<chrono::Utc>,
680}