Squashed 'crates/raster/' changes from 95b6ee0..4a3227c

4a3227c VCUE-1417 - parallax imagestore creation hook for Lustre PFL setup (#15)

git-subtree-dir: crates/raster
git-subtree-split: 4a3227cc93ab6dfb4b3d6ecbf5443bdf4cfc236e

Author: matteo-chesi

Cargo.toml

@@ -13,3 +13,4 @@ toml = "0.9.5"
 regex = "1.12.2"
 serial_test = "3.2.0"
 nix = { version = "0.30.1", features = ["user","fs","signal"] }
+is_executable = "1.0.5"

src/config.rs

@@ -9,6 +9,7 @@ const CONFIG_PATH: &str = "/etc/sarus-suite";
 #[derive(Serialize, Deserialize, Clone, Default)]
 pub struct RawConfig {
     edf_system_search_path: Option<String>,
+    hooks: Option<RawConfigHooks>,
     parallax_imagestore: Option<String>,
     parallax_mount_program: Option<String>,
     parallax_path: Option<String>,
@@ -26,10 +27,17 @@ pub struct RawConfig {
     tracking_tool: Option<String>,
 }
 
+#[derive(Serialize, Deserialize, Clone, Default)]
+pub struct RawConfigHooks {
+    parallax_imagestore_create: Option<String>,
+}
+
 #[derive(Serialize, Deserialize, Clone, Default)]
 pub struct Config {
     #[serde(default = "get_default_edf_system_search_path")]
     pub edf_system_search_path: String,
+    #[serde(default = "get_default_hooks")]
+    pub hooks: ConfigHooks,
     #[serde(default = "get_default_parallax_imagestore")]
     pub parallax_imagestore: String,
     #[serde(default = "get_default_parallax_mount_program")]
@@ -62,6 +70,12 @@ pub struct Config {
     pub tracking_tool: String,
 }
 
+#[derive(Serialize, Deserialize, Clone, Default)]
+pub struct ConfigHooks {
+    #[serde(default = "get_default_hook_parallax_imagestore_create")]
+    pub parallax_imagestore_create: String,
+}
+
 #[derive(Clone, Copy)]
 pub enum VarExpand {
     Never, // Do not expand variables.
@@ -134,13 +148,27 @@ fn get_default_tracking_tool() -> String {
     return String::from("");
 }
 
+fn get_default_hook_parallax_imagestore_create() -> String {
+    return String::from("");
+}
+
+fn get_default_hooks() -> ConfigHooks {
+    return ConfigHooks {
+        parallax_imagestore_create: get_default_hook_parallax_imagestore_create(),
+    }
+}
+
 impl From<RawConfig> for Config {
     fn from(r: RawConfig) -> Self {
         Config {
             edf_system_search_path: match r.edf_system_search_path {
                 Some(s) => s,
                 None => get_default_edf_system_search_path(),
             },
+            hooks: match r.hooks {
+                Some(s) => ConfigHooks::from(s),
+                None => get_default_hooks(),
+            },
             parallax_imagestore: match r.parallax_imagestore {
                 Some(s) => s,
                 None => get_default_parallax_imagestore(),
@@ -211,6 +239,9 @@ impl RawConfig {
         if i.edf_system_search_path.is_some() {
             self.edf_system_search_path = i.edf_system_search_path;
         }
+        if i.hooks.is_some() {
+            self.hooks = i.hooks;
+        }
         if i.parallax_imagestore.is_some() {
             self.parallax_imagestore = i.parallax_imagestore;
         }
@@ -259,6 +290,17 @@ impl RawConfig {
     }
 }
 
+impl From<RawConfigHooks> for ConfigHooks {
+    fn from(r: RawConfigHooks) -> Self {
+        ConfigHooks {
+            parallax_imagestore_create: match r.parallax_imagestore_create {
+                Some(s) => s,
+                None => get_default_hook_parallax_imagestore_create(),
+            },
+        }
+    }
+}
+
 fn validate_configfile(path: String) -> SarusResult<()> {
     // Embedding schema file
     let schema_content = include_str!("schema/config.json");
@@ -303,6 +345,7 @@ fn load_raw_config_from_file(
     };
 
     let mut r: RawConfig = toml_value;
+
     //let mut r: RawConfig = toml_read(path_str)?;
 
     // Expand variables in the fields
@@ -427,6 +470,14 @@ fn load_raw_config_from_dir(
 }
 
 pub fn update_config_by_user(config: &mut Config, edf: EDF) -> SarusResult<()> {
+    let parallax_imagestore_create = edf.annotations.get("com.sarus.hooks.parallax_imagestore_create");
+    if parallax_imagestore_create.is_some() {
+        match parallax_imagestore_create.unwrap().as_str() {
+            "false" => { config.hooks.parallax_imagestore_create = String::from("") },
+            _ => {},
+        }
+    }
+
     let parallax_imagestore = edf.annotations.get("com.sarus.parallax_imagestore");
     if parallax_imagestore.is_some() {
         config.parallax_imagestore = parallax_imagestore.unwrap().to_string();

src/hooks.rs

@@ -0,0 +1,104 @@
+use std::path::Path;
+use std::process::{Command, Output};
+use is_executable::IsExecutable;
+
+use crate::error::{SarusError, SarusResult};
+use crate::Config;
+
+pub struct ExecutedCommand {
+    pub command: String,
+    pub output: Output,
+}
+
+pub fn hook_run(config: &Config, name: &str, args: Vec<&str>) -> SarusResult<Option<ExecutedCommand>> {
+
+    let hook = match name {
+        "parallax_imagestore_create" => &config.hooks.parallax_imagestore_create,
+        _ => return Err(SarusError {
+                code: 26,
+                file_path: None,
+                msg: format!("unknown hook name: \"{name}\""),
+        }),
+    };
+
+    if hook == "" {
+        return Ok(None);
+    }
+
+    let hook_path = Path::new(&hook);
+
+    if ! hook_path.exists() {
+        return Err(SarusError {
+            code: 27,
+            file_path: None,
+            msg: format!("config.hooks.{name} file \"{hook}\" doesn't exist"),
+        });
+    }
+
+    if ! hook_path.is_executable() {
+        return Err(SarusError {
+            code: 28,
+            file_path: None,
+            msg: format!("config.hooks.{name} file \"{hook}\" isn't executable"),
+        });
+    }
+
+    let output = hook_run_path(hook_path, &args)?;
+    //let outstr = hook_output_to_string(output);
+
+    let ec = ExecutedCommand {
+        command: format!("{hook} {}", args.concat()),
+        output: output,
+    };
+
+    //Ok(format!("{name} hook executed: {hook} {}\n{name} hook {outstr}", args.concat()))
+    Ok(Some(ec))
+}
+
+fn hook_run_path(path: &Path, args: &Vec<&str>) -> SarusResult<Output> {
+
+    match Command::new(path)
+                .args(args)
+                .output() {
+        Ok(output) => Ok(output),
+        Err(err)    => return Err(SarusError {
+            code: 29,
+            file_path: None,
+            msg: format!("Running command \"{} {}\" error: {err}", path.display(), args.concat()),
+        }),
+    }
+}
+/*
+fn hook_output_to_string(output: Output) -> String {
+
+    let ret_result = match output.status.success() {
+        true => "succeeded",
+        false => "failed",
+    };
+
+    let ret_code = match output.status.code() {
+        Some(s) => s.to_string(),
+        None => String::from("UNKNOWN"),
+    };
+
+    let mut ret_stdout = match String::from_utf8(output.stdout) {
+        Ok(stdout) => String::from(stdout.strip_suffix("\n").unwrap_or(&stdout)),
+        Err(err) => format!("translation stdout error: \"{err}\""),
+    };
+
+    if ret_stdout != "" {
+        ret_stdout = format!("\nstdout:\n{ret_stdout}");
+    }
+
+    let mut ret_stderr = match String::from_utf8(output.stderr) {
+        Ok(stderr) => String::from(stderr.strip_suffix("\n").unwrap_or(&stderr)),
+        Err(err) => format!("translation stderr error: \"{err}\""),
+    };
+
+    if ret_stderr != "" {
+        ret_stderr = format!("\nstderr:\n{ret_stderr}");
+    }
+
+    return format!("{ret_result} with exit code: {ret_code}{ret_stdout}{ret_stderr}");
+}
+*/

src/lib.rs

@@ -15,10 +15,12 @@ use crate::mount::{SarusMounts, sarus_mounts_from_strings};
 pub mod common;
 pub mod config;
 pub mod error;
+pub mod hooks;
 pub mod mount;
 
 pub use crate::common::expand_vars_string;
 pub use crate::config::{Config, VarExpand, load_config, load_config_path, update_config_by_user};
+pub use crate::hooks::{hook_run, ExecutedCommand};
 
 #[allow(dead_code)]
 #[derive(Derivative, Serialize, Deserialize, Clone, Default)]

src/schema/config.json

@@ -10,6 +10,17 @@
       "description": "filesystem path where to load EDF files from",
       "type": "string"
     },
+    "hooks": {
+      "description": "Sarus Suite hooks table",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "parallax_imagestore_create": {
+          "description": "hook for parallax imagestore creation",
+          "type": "string"
+        }
+      }
+    },
     "parallax_imagestore": {
       "description": "shared filesystem path where to store/load images",
       "type": "string"