Merge pull request 'preboot' (#10) from preboot into master

Reviewed-on: http://192.168.2.61/VladislavD/runner-rs/pulls/10

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "runner-rs"
-version = "0.9.25"
+version = "0.10.11"
 edition = "2021"
 
 [profile.dev]
@@ -9,10 +9,10 @@ debug = true
 [profile.test]
 debug = false
 
-
 [dependencies]
 anyhow = "1.0.93"
 chrono = "0.4.38"
+clap = { version = "4.5.21", features = ["derive"] }
 env_logger = "0.11.3"
 inotify = "0.10.2"
 log = "0.4.22"

settings.json

@@ -4,12 +4,12 @@
   "processes": [
     {
       "name": "temp-process",
-      "path": "/usr/src/kii/temp-process",
+      "path": "./temp-process",
       "dependencies": {
         "files": [
           {
             "filename": "dep-file",
-            "src": "/usr/src/kii/tests/examples/",
+            "src": "./tests/examples/",
             "triggers": {
               "onDelete": "stop",
               "onChange": "stay"

src/main.rs

@@ -1,18 +1,27 @@
 mod options;
 mod utils;
 
+use clap::Parser;
 use log::{error, info};
-use options::config::*;
+use options::{config::*, preboot};
 use options::logger::setup_logger;
 use options::signals::set_valid_destructor;
-use options::structs::*;
+use options::structs::Processes;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::mpsc;
 use utils::*;
+#[allow(unused_imports)]
+use options::preboot::PrebootParams;
 
 #[tokio::main(flavor = "multi_thread")]
 async fn main() {
+    let preboot = PrebootParams::parse().validate();
+    
+    if let Err(_) = preboot {        
+        return;
+    }
+
     let _ = setup_logger();
 
     info!("Runner is configurating...");

src/options.rs

@@ -4,3 +4,4 @@ pub mod config;
 pub mod logger;
 pub mod signals;
 pub mod structs;
+pub mod preboot;

src/options/preboot.rs

@@ -0,0 +1,196 @@
+// module to handle pre-boot params of the monitor
+use anyhow::{Result, Ok, Error};
+use clap::Parser;
+use std::path::PathBuf;
+
+#[derive(clap::ValueEnum, Debug, Clone)]
+enum MetricsPrebootParams {
+    Full, 
+    System,
+    Processes,
+    Net,
+    None,
+}
+
+impl std::fmt::Display for MetricsPrebootParams { 
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { 
+        match self {
+            MetricsPrebootParams::Full => write!(f, "full"),
+            MetricsPrebootParams::System => write!(f, "system"),
+            MetricsPrebootParams::Processes => write!(f, "processes"),
+            MetricsPrebootParams::Net => write!(f, "net"),
+            MetricsPrebootParams::None => write!(f, "none"),
+        }
+    } 
+} 
+
+#[derive(Debug, Parser)]
+pub struct PrebootParams {
+    // actions
+    #[arg(
+        long = "no-hagent", 
+        action, 
+        conflicts_with="socket_path", 
+        help="To disable work with host-agent"
+    )]
+    pub no_hostagent : bool,
+    #[arg(
+        long = "no-logs", 
+        action, 
+        conflicts_with="log_to", 
+        help="To disable logs"
+    )]
+    pub no_logs: bool,
+    #[arg(
+        long = "refresh-logs", 
+        action, 
+        conflicts_with="no_logs", 
+        help="To clear logs directory"
+    )]
+    pub refresh_logs : bool,
+    #[arg(
+        long = "no-remote-config", 
+        action, 
+        help="To disable work with remote config server", 
+        conflicts_with="no_sub")]
+    pub no_remote_config : bool,
+    #[arg(
+        long = "no-sub", 
+        action, 
+        help="To disable subscription mechanism", 
+        conflicts_with="no_remote_config")]
+    pub no_sub : bool,
+    
+    // params (socket_path, log_to, remote_server_url, config)
+    #[arg(
+        long = "socket-path", 
+        default_value="/var/run/enode/hostagent.sock", 
+        conflicts_with="no_hostagent", 
+        help="To set .sock file's path used in communication with host-agent"
+    )]
+    socket_path : PathBuf,
+    #[arg(
+        long = "log-to", 
+        default_value="./", 
+        conflicts_with="no_logs", 
+        help="To set a path to logs directory"
+    )]
+    log_to : PathBuf,
+    #[arg(
+        long = "remote-server-url", 
+        default_value="redis://localhost", 
+        conflicts_with="no_remote_config", 
+        help = "To set url of remote config server using in remote config pulling mechanism"
+    )]
+    remote_server_url : String,
+    #[arg(
+        long = "config", 
+        short, 
+        default_value="settings.json", 
+        help="To set local config file path"
+    )]
+    config : PathBuf,
+
+    // value enum params (metrics)
+    #[arg(
+        long = "metrics", 
+        short, 
+        default_value_t=MetricsPrebootParams::Full, 
+        help="To set metrics grubbing mode"
+    )]
+    metrics: MetricsPrebootParams,
+}
+
+impl PrebootParams {
+    pub fn validate(self) -> Result<Self> {
+        if !self.socket_path.exists() {
+            eprintln!("Socket-file {} doesn't exist. Cannot start", &self.socket_path.display());
+            return Err(Error::msg("Socket-file Not Found"));
+        }
+        // existing log dir
+        if !self.log_to.exists() {
+            eprintln!("Log directory {} doesn't exist", &self.log_to.display());
+            return Err(Error::msg("Log Directory Not Found. Cannot start"));
+        }
+        // existing sock file
+        if !self.config.exists() {
+            eprintln!("Local config file {} doesn't exist", &self.config.display());
+            return Err(Error::msg("Local Config Not Found. Cannot start"));
+        }
+        Ok(self)
+    }
+}
+
+
+// unit tests of preboot params parsing mech
+#[cfg(test)]
+mod preboot_unitests{
+    use super::*;
+
+    #[test]
+    fn parsing_zero_args() {
+        assert!(PrebootParams::try_parse_from(vec!["runner-rs"]).is_ok())    
+    }
+    #[test]
+    fn parsing_hagent_valid_args() {
+        assert!(PrebootParams::try_parse_from(vec![
+            "runner-rs", 
+            "--socket-path", "/path/to/socket"
+        ]).is_ok())    
+}
+    #[test]
+    fn parsing_hagent_invalid_args() {
+        assert!(PrebootParams::try_parse_from(vec![
+            "runner-rs", 
+            "--socket-path", "/path/to/socket", 
+            "--no-hagent"
+        ]).is_err())    
+    }
+    #[test]
+    fn parsing_log_valid_args() {
+        assert!(PrebootParams::try_parse_from(vec![
+            "runner-rs", 
+            "--log-to", "/path/to/log/dir"
+        ]).is_ok())    
+    }
+    #[test]
+    fn parsing_log_invalid_args() {
+        assert!(PrebootParams::try_parse_from(vec![
+            "runner-rs", 
+            "--log-to /path/to/log/dir", 
+            "--no-logs"
+        ]).is_err())
+    }
+    #[test]
+    fn parsing_config_valid_args() {
+        assert!(PrebootParams::try_parse_from(vec![
+            "runner-rs", 
+            "--no-sub", 
+            "--remote-server-url", "redis://127.0.0.1"
+        ]).is_ok())    
+    }
+    #[test]
+    fn parsing_config_invalid_args_noremote_nosub() {
+        assert!(PrebootParams::try_parse_from(vec![
+            "runner-rs", 
+            "--no-remote-config", "--no-sub"
+        ]).is_err())    
+    }
+    #[test]
+    fn parsing_config_invalid_args_noremote_remoteurl() {
+        assert!(PrebootParams::try_parse_from(vec![
+            "runner-rs", 
+            "--no-remote-config", 
+            "--remote-server-url", "redis://127.0.0.1"
+        ]).is_err())    
+    }
+    #[test]
+    fn parsing_metrics_args_using_value_enum() {
+        assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "full"]).is_ok());
+        assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "system"]).is_ok());
+        assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "processes"]).is_ok());
+        assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "net"]).is_ok());
+        assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "none"]).is_ok());
+        assert!(PrebootParams::try_parse_from(vec!["runner-rs", "--metrics", "unusual_value"]).is_err());
+    }
+}

src/options/structs.rs

@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
 pub enum CustomError {
     Fatal,
 }
+
 #[derive(Debug, PartialEq)]
 pub enum ConfigActuality {
     Local,

src/utils/hagent.rs

@@ -1,6 +1,10 @@
+// 
 // module needed to check host-agent health condition and to communicate with it
+// 
 use tokio::{io::Interest, net::UnixStream};
 use anyhow::{Ok, Result, Error};
+// to kill lint bug 
+#[allow(unused_imports)]
 use tokio::net::UnixListener;
 
 /// # Fn `open_unix_socket`
@@ -16,6 +20,7 @@ use tokio::net::UnixListener;
 ///
 /// *depends on* : -
 /// 
+#[allow(dead_code)]
 async fn open_unix_socket(sock_path: &str) -> Result<UnixStream, std::io::Error> {
     // "/var/run/enode/hostagent.sock"
     UnixStream::connect(sock_path).await
@@ -34,6 +39,7 @@ async fn open_unix_socket(sock_path: &str) -> Result<UnixStream, std::io::Error>
 ///
 /// *depends on* : -
 /// 
+#[allow(dead_code)]
 async fn ha_healthcheck(socket: &UnixStream) -> Result<(), Error> {
     socket.ready(Interest::WRITABLE).await?;
     socket.writable().await?;
@@ -54,6 +60,7 @@ async fn ha_healthcheck(socket: &UnixStream) -> Result<(), Error> {
 ///
 /// *depends on* : -
 /// 
+#[allow(dead_code)]
 async fn ha_send_data(socket: &UnixStream, data: &str) -> Result<(), Error > {
     socket.ready(Interest::WRITABLE).await?;
     socket.writable().await?;
@@ -70,20 +77,20 @@ mod hagent_unittets {
         let _ = std::fs::remove_file(TEST_SOCKET);
         UnixListener::bind(TEST_SOCKET).unwrap()
     }
-    #[tokio::test]
-    // maybe bool : true -> alive, false -> dead
-    // simple request on api
-    async fn hagent_healthcheck() {
-        let mut list = init_listener().await;
-        let sock = open_unix_socket(TEST_SOCKET).await;
-        assert!(sock.is_ok());
-        let mut sock = sock.unwrap();
-        assert!(ha_healthcheck(&sock).await.is_ok());
-    }
+    // #[tokio::test]
+    // // maybe bool : true -> alive, false -> dead
+    // // simple request on api
+    // async fn hagent_healthcheck() {
+    //     let _ = init_listener().await;
+    //     let sock = open_unix_socket(TEST_SOCKET).await;
+    //     assert!(sock.is_ok());
+    //     let sock = sock.unwrap();
+    //     assert!(ha_healthcheck(&sock).await.is_ok());
+    // }
     #[tokio::test]
     // --Result<maybe Response>
     // one-shot func
-    async fn send_metrics_to_hagent() {
+    async fn hagent_communication_test() {
         use crate::options::structs::{ProcessMetrics, ContainerMetrics, Metrics};
         
         let procm = ProcessMetrics::new("test-prc", 15.0, 5.0);
@@ -91,17 +98,17 @@ mod hagent_unittets {
         let metrics = Metrics::new(contm, vec![procm]);
         let metrics = &serde_json::to_string_pretty(&metrics).unwrap();
 
-        let mut list = init_listener().await;
+        #[allow(unused_mut)]
+        let mut _list = init_listener().await;
         let sock = open_unix_socket(TEST_SOCKET).await;
         assert!(sock.is_ok());
-        let mut sock = sock.unwrap();
+        let sock = sock.unwrap();
         assert!(ha_healthcheck(&sock).await.is_ok());
         assert!(ha_send_data(&sock, &metrics).await.is_ok());
 
     }
     #[tokio::test]
     async fn open_unixsocket_test() {
-        let mut list = init_listener().await;
-        assert!(open_unix_socket(TEST_SOCKET).await.is_ok());
+        assert!(open_unix_socket("non/valid/socket/file.sock").await.is_err());
     }
-}
+}

src/utils/metrics.rs

@@ -27,6 +27,7 @@ use crate::utils::get_container_id;
 ///
 /// *depends on* : -  
 /// 
+#[allow(dead_code)]
 pub async fn init_metrics_grubber() { 
     let mut system = System::new();
     // let mut buffer: Vec<PacketInfo> = vec![];
@@ -39,6 +40,8 @@ pub async fn init_metrics_grubber() {
     // let _ = capture_packets(shared_buf.clone()).await;
 }
 
+#[allow(dead_code)]
+#[allow(unused_variables)]
 async fn gather_metrics(proc: Arc<Process>) {
     
 }
@@ -92,6 +95,7 @@ async fn gather_metrics(proc: Arc<Process>) {
 ///
 /// *depends on* : `TrackingProcess`
 /// 
+#[allow(dead_code)]
 async fn get_all_container_metrics(sys: Arc<System>, prcs: Arc<Vec<TrackingProcess>>) -> ContainerMetrics {
     let metrics = join!(
         get_cpu_metrics_container(sys.clone()),
@@ -119,6 +123,7 @@ async fn get_all_container_metrics(sys: Arc<System>, prcs: Arc<Vec<TrackingProce
 ///
 /// *depends on* : -  
 /// 
+#[allow(dead_code)]
 async fn get_cpu_metrics_container(sys: Arc<System>) -> f32 {
     sys.global_cpu_usage()
 }
@@ -136,6 +141,7 @@ async fn get_cpu_metrics_container(sys: Arc<System>) -> f32 {
 ///
 /// *depends on* : -  
 /// 
+#[allow(dead_code)]
 async fn get_ram_metrics_container(sys: Arc<System>) -> f32 {
     (sys.used_memory() / sys.total_memory()) as f32 * 100.0 
 }
@@ -156,6 +162,7 @@ async fn get_ram_metrics_container(sys: Arc<System>) -> f32 {
 ///
 /// *depends on* : `TrackingProcess`  
 /// 
+#[allow(dead_code)]
 async fn get_subsystems(prcs: Arc<Vec<TrackingProcess>>) -> Vec<String> {
     prcs.iter().map(|process| process.name.clone()).collect()
 }
@@ -173,6 +180,7 @@ async fn get_subsystems(prcs: Arc<Vec<TrackingProcess>>) -> Vec<String> {
 ///
 /// *depends on* : -
 /// 
+#[allow(dead_code)]
 async fn get_all_metrics_process(proc: Arc<Process>, sys: Arc<System>) -> ProcessMetrics {
     let metrics = join!(
         get_cpu_metrics_process(proc.clone()),

src/utils/prcs.rs

@@ -223,7 +223,6 @@ pub async fn start_process(name: &str, path: &str) -> Result<(), CustomError> {
 
 #[cfg(test)]
 mod process_unittests {
-    use std::io::Write;
     use super::*;
     // 1 full cycle - start -> restart -> stop
     // 2 full cycle - start -> freeze -> unfreze -> stop