[pbs-devel] [PATCH v4 proxmox 28/31] api/api-types: refactor api endpoint version, add api types

[Christian Ebner]

Add a dedicated api type for the `version` api endpoint and the type
to allow for version comparisons. Will be used for version
comparisons in order to detect older hosts with slightly different
api parameters.

Use the new api type to refactor the version endpoint and set it as
return type.

Signed-off-by: Christian Ebner <c.ebner at proxmox.com>
---
changes since version 3:
- not present in previous version

 pbs-api-types/src/lib.rs     |  3 ++
 pbs-api-types/src/version.rs | 98 ++++++++++++++++++++++++++++++++++++
 src/api2/version.rs          | 39 +++++++-------
 3 files changed, 123 insertions(+), 17 deletions(-)
 create mode 100644 pbs-api-types/src/version.rs

diff --git a/pbs-api-types/src/lib.rs b/pbs-api-types/src/lib.rs
index 635292a54..e0abfd963 100644
--- a/pbs-api-types/src/lib.rs
+++ b/pbs-api-types/src/lib.rs
@@ -155,6 +155,9 @@ pub use zfs::*;
 mod metrics;
 pub use metrics::*;
 
+mod version;
+pub use version::*;
+
 const_regex! {
     // just a rough check - dummy acceptor is used before persisting
     pub OPENSSL_CIPHERS_REGEX = r"^[0-9A-Za-z_:, +!\-@=.]+$";
diff --git a/pbs-api-types/src/version.rs b/pbs-api-types/src/version.rs
new file mode 100644
index 000000000..9811b2c21
--- /dev/null
+++ b/pbs-api-types/src/version.rs
@@ -0,0 +1,98 @@
+//! Defines the types for the api version info endpoint
+use std::cmp::Ordering;
+use std::convert::TryFrom;
+
+use anyhow::Context;
+
+use proxmox_schema::api;
+
+#[api(
+    description: "Api version information",
+    properties: {
+        "version": {
+            description: "Version 'major.minor'",
+            type: String,
+        },
+        "release": {
+            description: "Version release",
+            type: String,
+        },
+        "repoid": {
+            description: "Version repository id",
+            type: String,
+        }
+    }
+)]
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct ApiVersionInfo {
+    pub version: String,
+    pub release: String,
+    pub repoid: String,
+}
+
+pub type ApiVersionMajor = u64;
+pub type ApiVersionMinor = u64;
+pub type ApiVersionRelease = u64;
+
+pub struct ApiVersion {
+    major: ApiVersionMajor,
+    minor: ApiVersionMinor,
+    release: ApiVersionRelease,
+}
+
+impl TryFrom<ApiVersionInfo> for ApiVersion {
+    type Error = anyhow::Error;
+
+    fn try_from(value: ApiVersionInfo) -> Result<Self, Self::Error> {
+        let mut parts = value.version.split('.');
+        let major: ApiVersionMajor = if let Some(val) = parts.next() {
+            val.parse()
+                .with_context(|| "failed to parse major version")?
+        } else {
+            ApiVersionMajor::default()
+        };
+        let minor: ApiVersionMinor = if let Some(val) = parts.next() {
+            val.parse()
+                .with_context(|| "failed to parse minor version")?
+        } else {
+            ApiVersionMinor::default()
+        };
+
+        let release: ApiVersionMinor = value
+            .release
+            .parse()
+            .with_context(|| "failed to parse release version")?;
+
+        Ok(Self {
+            major,
+            minor,
+            release,
+        })
+    }
+}
+
+impl ApiVersion {
+    pub fn new(major: ApiVersionMajor, minor: ApiVersionMinor, release: ApiVersionRelease) -> Self {
+        Self {
+            major,
+            minor,
+            release,
+        }
+    }
+
+    pub fn is_min_required(&self, version: ApiVersion) -> bool {
+        match (
+            version.major.cmp(&self.major),
+            version.minor.cmp(&self.minor),
+            version.release.cmp(&self.release),
+        ) {
+            (Ordering::Less, _, _) => true,
+            (Ordering::Greater, _, _) => false,
+            (Ordering::Equal, Ordering::Less, _) => true,
+            (Ordering::Equal, Ordering::Greater, _) => false,
+            (Ordering::Equal, Ordering::Equal, Ordering::Less) => true,
+            (Ordering::Equal, Ordering::Equal, Ordering::Equal) => true,
+            (Ordering::Equal, Ordering::Equal, Ordering::Greater) => false,
+        }
+    }
+}
diff --git a/src/api2/version.rs b/src/api2/version.rs
index 0e91688b5..4d104f2d6 100644
--- a/src/api2/version.rs
+++ b/src/api2/version.rs
@@ -1,27 +1,32 @@
 //! Version information
 
 use anyhow::Error;
-use serde_json::{json, Value};
+use serde_json::Value;
 
-use proxmox_router::{ApiHandler, ApiMethod, Permission, Router, RpcEnvironment};
-use proxmox_schema::ObjectSchema;
+use proxmox_router::{ApiMethod, Permission, Router, RpcEnvironment};
+use proxmox_schema::api;
 
-fn get_version(
+use pbs_api_types::ApiVersionInfo;
+
+#[api(
+    returns: {
+        type: ApiVersionInfo,
+    },
+    access: {
+        permission: &Permission::Anybody,
+    }
+)]
+///Proxmox Backup Server API version.
+fn version(
     _param: Value,
     _info: &ApiMethod,
     _rpcenv: &mut dyn RpcEnvironment,
-) -> Result<Value, Error> {
-    Ok(json!({
-        "version": pbs_buildcfg::PROXMOX_PKG_VERSION,
-        "release": pbs_buildcfg::PROXMOX_PKG_RELEASE,
-        "repoid": pbs_buildcfg::PROXMOX_PKG_REPOID
-    }))
+) -> Result<ApiVersionInfo, Error> {
+    Ok(ApiVersionInfo {
+        version: pbs_buildcfg::PROXMOX_PKG_VERSION.to_string(),
+        release: pbs_buildcfg::PROXMOX_PKG_RELEASE.to_string(),
+        repoid: pbs_buildcfg::PROXMOX_PKG_REPOID.to_string(),
+    })
 }
 
-pub const ROUTER: Router = Router::new().get(
-    &ApiMethod::new(
-        &ApiHandler::Sync(&get_version),
-        &ObjectSchema::new("Proxmox Backup Server API version.", &[]),
-    )
-    .access(None, &Permission::Anybody),
-);
+pub const ROUTER: Router = Router::new().get(&API_METHOD_VERSION);
-- 
2.39.5