[PATCH proxmox 04/28] pbs-api-types: extend sync job config by retention-timespan parameter

[Christian Ebner <c.ebner@proxmox.com>]

Allows to configure a sync job which sets a retention timestamp on
synced snapshots based on the start time of the sync.

Signed-off-by: Christian Ebner <c.ebner@proxmox.com>
---
 pbs-api-types/src/jobs.rs | 64 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 63 insertions(+), 1 deletion(-)

diff --git a/pbs-api-types/src/jobs.rs b/pbs-api-types/src/jobs.rs
index 9a5d2b77..6aa4e3a0 100644
--- a/pbs-api-types/src/jobs.rs
+++ b/pbs-api-types/src/jobs.rs
@@ -1,7 +1,8 @@
-use std::str::FromStr;
+use std::{fmt, str::FromStr};
 
 use anyhow::bail;
 use const_format::concatcp;
+use proxmox_time::TimeSpan;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 
@@ -94,6 +95,61 @@ pub const SYNC_WORKER_THREADS_SCHEMA: Schema = threads_schema(
     1,
 );
 
+pub const RETENTION_TIMESPAN_FORMAT: ApiStringFormat = ApiStringFormat::VerifyFn(|s| {
+    RetentionTimespan::from_str(s)?;
+    Ok(())
+});
+
+pub const RETENTION_TIMESPAN_SCHEMA: Schema = StringSchema::new("Retention timespan")
+    .format(&RETENTION_TIMESPAN_FORMAT)
+    .schema();
+
+#[derive(Clone, Debug, PartialEq, UpdaterType)]
+pub struct RetentionTimespan {
+    timespan: TimeSpan,
+}
+
+impl std::str::FromStr for RetentionTimespan {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let timespan: TimeSpan = s.parse()?;
+        if timespan.subsec_nanos() > 0 {
+            bail!("Sub-second precision not supported by retention timespan");
+        }
+        Ok(Self { timespan })
+    }
+}
+
+impl fmt::Display for RetentionTimespan {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.timespan)
+    }
+}
+
+impl ApiType for RetentionTimespan {
+    const API_SCHEMA: Schema = RETENTION_TIMESPAN_SCHEMA;
+}
+
+impl RetentionTimespan {
+    /// Provide the retention timespan as plain timespan
+    pub fn as_timespan(&self) -> &TimeSpan {
+        &self.timespan
+    }
+
+    /// Calculate the unix epoch for given retenition timespan relative to now from system time.
+    pub fn to_timestamp_from_systemtime(&self) -> Result<i64, anyhow::Error> {
+        // no sub-second precision allowed by parser, safe to skip
+        match proxmox_time::epoch_i64().checked_add_unsigned(self.timespan.as_secs()) {
+            Some(timestamp) => Ok(timestamp),
+            None => bail!("retention timestamp calculation failed with overflow"),
+        }
+    }
+}
+
+serde_plain::derive_serialize_from_display!(RetentionTimespan);
+serde_plain::derive_deserialize_from_fromstr!(RetentionTimespan, "retention timespan");
+
 #[api(
     properties: {
         "next-run": {
@@ -690,6 +746,10 @@ pub const UNMOUNT_ON_SYNC_DONE_SCHEMA: Schema =
             },
             optional: true,
         },
+        "retention-timespan": {
+            type: RetentionTimespan,
+            optional: true,
+        },
     }
 )]
 #[derive(Serialize, Deserialize, Clone, Updater, PartialEq)]
@@ -741,6 +801,8 @@ pub struct SyncJobConfig {
     pub active_encryption_key: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub associated_key: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retention_timespan: Option<RetentionTimespan>,
 }
 
 impl SyncJobConfig {
-- 
2.47.3