chore: added ods version compatibility check

Cargo.toml

@@ -7,7 +7,7 @@ license = "MIT OR Apache-2.0"
 name = "omnect-ui"
 readme = "README.md"
 repository = "git@github.com:omnect/omnect-ui.git"
-version = "0.13.3"
+version = "0.14.0"
 build = "src/build.rs"
 
 [dependencies]
@@ -50,6 +50,7 @@ rustls = { version = "0.23", default-features = false, features = [
 rustls-pemfile = { version = "2.2", default-features = false, features = [
   "std",
 ] }
+semver = { version = "1.0", default-features = false }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0", default-features = false, features = [
   "raw_value",

src/api.rs

@@ -1,4 +1,4 @@
-use crate::common::{config_path, validate_password, validate_token_and_claims};
+use crate::common::{config_path, validate_password, validate_token_and_claims, VERSION_CHECK};
 use crate::middleware::TOKEN_EXPIRE_HOURS;
 use crate::socket_client::*;
 use actix_files::NamedFile;
@@ -113,7 +113,16 @@ impl Api {
 
     pub async fn healthcheck() -> impl Responder {
         debug!("healthcheck() called");
-        HttpResponse::Ok().finish()
+
+        if let Some(result) = VERSION_CHECK.get() {
+            if result.version_mismatch {
+                HttpResponse::ServiceUnavailable().json(result)
+            } else {
+                HttpResponse::Ok().json(result)
+            }
+        } else {
+            HttpResponse::Ok().body("No version check performed yet")
+        }
     }
 
     pub async fn factory_reset(

src/common.rs

@@ -1,11 +1,22 @@
+use crate::REQ_ODS_VERSION;
 use actix_web::body::MessageBody;
 use anyhow::{anyhow, bail, Context, Result};
 use argon2::{Argon2, PasswordHash, PasswordVerifier};
 use base64::{prelude::BASE64_STANDARD, Engine};
 use jwt_simple::prelude::{RS256PublicKey, RSAPublicKeyLike};
 use reqwest::blocking::get;
+use semver::{Version, VersionReq};
 use serde::{Deserialize, Serialize};
-use std::{fs, io::Write, path::Path};
+use std::{fs, io::Write, path::Path, sync::OnceLock};
+
+pub static VERSION_CHECK: OnceLock<VersionCheckResult> = OnceLock::new();
+
+#[derive(Clone, Debug, Serialize)]
+pub struct VersionCheckResult {
+    pub req_ods_version: String,
+    pub cur_ods_version: String,
+    pub version_mismatch: bool,
+}
 
 #[derive(Deserialize)]
 pub struct RealmInfo {
@@ -30,6 +41,7 @@ pub struct StatusResponse {
 #[derive(Deserialize)]
 pub struct SystemInfo {
     pub fleet_id: Option<String>,
+    omnect_device_service_version: String,
 }
 
 #[derive(Deserialize)]
@@ -199,3 +211,27 @@ pub fn create_frontend_config_file(keycloak_url: &str) -> Result<()> {
 
     Ok(())
 }
+
+pub async fn check_and_store_ods_version(ods_socket_path: &str) -> Result<()> {
+    let status_response = get_status(ods_socket_path)
+        .await
+        .context("failed to get status from socket client")?;
+
+    let version_req = VersionReq::parse(REQ_ODS_VERSION)
+        .map_err(|e| anyhow!("failed to parse REQ_ODS_VERSION: {e}"))?;
+    let current_version =
+        Version::parse(&status_response.system_info.omnect_device_service_version)
+            .map_err(|e| anyhow!("failed to parse omnect_device_service_version: {e}"))?;
+    let version_mismatch = !version_req.matches(&current_version);
+
+    VERSION_CHECK.get_or_init(|| VersionCheckResult {
+        req_ods_version: REQ_ODS_VERSION.to_string(),
+        cur_ods_version: status_response
+            .system_info
+            .omnect_device_service_version
+            .clone(),
+        version_mismatch,
+    });
+
+    Ok(())
+}

src/main.rs

@@ -29,6 +29,8 @@ use tokio::{
 };
 use uuid::Uuid;
 
+pub const REQ_ODS_VERSION: &str = ">=0.39.0";
+
 const UPLOAD_LIMIT_BYTES: usize = 250 * 1024 * 1024;
 const MEMORY_LIMIT_BYTES: usize = 10 * 1024 * 1024;
 
@@ -120,11 +122,22 @@ async fn main() {
         .parse::<u64>()
         .expect("UI_PORT format");
 
+    let ods_socket_path = std::env::var("SOCKET_PATH").expect("env SOCKET_PATH is missing");
+    fs::exists(&ods_socket_path).unwrap_or_else(|_| {
+        panic!(
+            "omnect device service socket file {} does not exist",
+            &ods_socket_path
+        )
+    });
+    common::check_and_store_ods_version(&ods_socket_path)
+        .await
+        .expect("failed to check and store ods version");
+
     CryptoProvider::install_default(default_provider()).expect("failed to install crypto provider");
 
     certificate::create_module_certificate(&cert_path!(), &key_path!())
         .await
-        .expect("Failed to create module certificate");
+        .expect("failed to create module certificate");
 
     let mut tls_certs =
         std::io::BufReader::new(std::fs::File::open(cert_path!()).expect("read certs_file"));
@@ -166,19 +179,11 @@ async fn main() {
         &centrifugo_http_server_port!(),
     );
 
-    let ods_socket_path = std::env::var("SOCKET_PATH").expect("env SOCKET_PATH is missing");
     let index_html =
         std::fs::canonicalize("static/index.html").expect("static/index.html not found");
 
     let tenant = std::env::var("TENANT").expect("env TENANT is missing");
 
-    fs::exists(&ods_socket_path).unwrap_or_else(|_| {
-        panic!(
-            "omnect device service socket file {} does not exist",
-            &ods_socket_path
-        )
-    });
-
     fs::exists(&update_os_path!())
         .unwrap_or_else(|_| panic!("path {} for os update does not exist", &update_os_path!()));