[pbs-devel] [PATCH proxmox-backup v5 1/8] api-types: add maintenance type

[Hannes Laimer]

Signed-off-by: Hannes Laimer <h.laimer at proxmox.com>
---
 pbs-api-types/src/datastore.rs   |  8 +++-
 pbs-api-types/src/lib.rs         |  3 ++
 pbs-api-types/src/maintenance.rs | 82 ++++++++++++++++++++++++++++++++
 3 files changed, 92 insertions(+), 1 deletion(-)
 create mode 100644 pbs-api-types/src/maintenance.rs

diff --git a/pbs-api-types/src/datastore.rs b/pbs-api-types/src/datastore.rs
index 36279b3a..e2491a92 100644
--- a/pbs-api-types/src/datastore.rs
+++ b/pbs-api-types/src/datastore.rs
@@ -7,7 +7,7 @@ use proxmox_schema::{
 
 use crate::{
     PROXMOX_SAFE_ID_FORMAT, SHA256_HEX_REGEX, SINGLE_LINE_COMMENT_SCHEMA, CryptMode, UPID,
-    Fingerprint, Userid, Authid,
+    Fingerprint, Userid, Authid, MaintenanceType,
     GC_SCHEDULE_SCHEMA, DATASTORE_NOTIFY_STRING_SCHEMA, PRUNE_SCHEDULE_SCHEMA,
 
 };
@@ -224,6 +224,10 @@ pub struct PruneOptions {
             optional: true,
             type: bool,
         },
+        "maintenance-type": {
+            optional: true,
+            type: MaintenanceType,
+        },
     }
 )]
 #[derive(Serialize,Deserialize,Updater)]
@@ -261,6 +265,8 @@ pub struct DataStoreConfig {
     /// Send notification only for job errors
     #[serde(skip_serializing_if="Option::is_none")]
     pub notify: Option<String>,
+    #[serde(skip_serializing_if="Option::is_none")]
+    pub maintenance_type: Option<MaintenanceType>,
 }
 
 #[api(
diff --git a/pbs-api-types/src/lib.rs b/pbs-api-types/src/lib.rs
index 754e7b22..efb01c3e 100644
--- a/pbs-api-types/src/lib.rs
+++ b/pbs-api-types/src/lib.rs
@@ -49,6 +49,9 @@ pub use jobs::*;
 mod key_derivation;
 pub use key_derivation::{Kdf, KeyInfo};
 
+mod maintenance;
+pub use maintenance::*;
+
 mod network;
 pub use network::*;
 
diff --git a/pbs-api-types/src/maintenance.rs b/pbs-api-types/src/maintenance.rs
new file mode 100644
index 00000000..4d3ccb3b
--- /dev/null
+++ b/pbs-api-types/src/maintenance.rs
@@ -0,0 +1,82 @@
+use anyhow::{bail, Error};
+
+use proxmox_schema::{ApiStringFormat, Schema, StringSchema, UpdaterType};
+
+use crate::{PROXMOX_SAFE_ID_FORMAT, SINGLE_LINE_COMMENT_FORMAT};
+
+pub const MAINTENANCE_MODE_SCHEMA: Schema = StringSchema::new("Maintenance mode.")
+    .format(&PROXMOX_SAFE_ID_FORMAT)
+    .min_length(3)
+    .max_length(32)
+    .schema();
+
+pub const MAINTENANCE_MESSAGE_SCHEMA: Schema =
+    StringSchema::new("Message describing the reason for the maintenance.")
+        .format(&SINGLE_LINE_COMMENT_FORMAT)
+        .max_length(32)
+        .schema();
+
+#[derive(UpdaterType)]
+/// Maintenance type and message.
+pub enum MaintenanceType {
+    /// Only reading operations are allowed on the datastore.
+    ReadOnly(String),
+    /// Neither reading nor writing operations are allowed on the datastore.
+    Offline(String),
+}
+
+/// Operation requirments, used when checking for maintenance mode.
+pub enum Operation {
+    Read,
+    Write,
+}
+
+proxmox_serde::forward_deserialize_to_from_str!(MaintenanceType);
+proxmox_serde::forward_serialize_to_display!(MaintenanceType);
+
+impl proxmox_schema::ApiType for MaintenanceType {
+    const API_SCHEMA: Schema = StringSchema::new(
+        "Maintenance type (e.g. 'read-only-<message>', 'offline-<message>')",
+    )
+    .format(&ApiStringFormat::VerifyFn(|text| {
+        let location: MaintenanceType = text.parse()?;
+        match location {
+            MaintenanceType::ReadOnly(ref message) => {
+                MAINTENANCE_MESSAGE_SCHEMA.parse_simple_value(message)?;
+            }
+            MaintenanceType::Offline(ref message) => {
+                MAINTENANCE_MESSAGE_SCHEMA.parse_simple_value(message)?;
+            }
+        }
+        Ok(())
+    }))
+    .schema();
+}
+
+impl std::fmt::Display for MaintenanceType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MaintenanceType::ReadOnly(message) => {
+                write!(f, "read-only-{}", message)
+            }
+            MaintenanceType::Offline(message) => {
+                write!(f, "offline-{}", message)
+            }
+        }
+    }
+}
+
+impl std::str::FromStr for MaintenanceType {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Some(message) = s.strip_prefix("read-only-") {
+            return Ok(MaintenanceType::ReadOnly(message.to_string()));
+        }
+        if let Some(message) = s.strip_prefix("offline-") {
+            return Ok(MaintenanceType::Offline(message.to_string()));
+        }
+
+        bail!("Maintenance type parse error");
+    }
+}
-- 
2.30.2