delete unused folder, fix unit test error

src/agent/nodeagent/src/bluechi/filemaker.rs

@@ -45,7 +45,7 @@ pub async fn make_symlink(node_name: &str, model_name: &str) -> common::Result<(
     );
     let link = format!("{}{}.kube", SYSTEMD_PATH, model_name);
 
-    let _ = std::os::unix::fs::symlink(original, link)?;
+    std::os::unix::fs::symlink(original, link)?;
 
     Ok(())
 }
@@ -107,23 +107,23 @@ fn make_yaml_file(dir: &str, pod: Pod) -> common::Result<()> {
     Ok(())
 }
 
-/// (under construction) Copy Bluechi files to other nodes
-///
-/// ### Parametets
-/// TBD
-/// ### Description
-/// TBD
-pub fn copy_to_remote_node(file_names: Vec<String>) -> common::Result<()> {
+// (under construction) Copy Bluechi files to other nodes
+//
+// ### Parametets
+// TBD
+// ### Description
+// TBD
+/*pub fn copy_to_remote_node(file_names: Vec<String>) -> common::Result<()> {
     Ok(())
-}
+}*/
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use common::spec::k8s::pod::PodSpec;
     use serde_yaml;
     use std::fs;
-    use std::path::{Path, PathBuf};
+    use std::path::Path;
 
     /// Returns a dummy PodSpec for testing
     fn dummy_podspec() -> PodSpec {
@@ -145,11 +145,11 @@ containers:
 
         let storage_dir = "/etc/piccolo/yaml";
         tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
-        let result = make_files_from_pod(vec![pod.clone()]).await;
+        let result = make_files_from_pod(vec![pod.clone()], "node1".to_string()).await;
 
         match result {
-            Ok(created_files) => {
-                assert_eq!(created_files, vec![pod.get_name()]);
+            Ok(_) => {
+                //assert_eq!(created_files, vec![pod.get_name()]);
 
                 let kube_path = format!("{}/{}.kube", storage_dir, pod.get_name());
                 let yaml_path = format!("{}/{}.yaml", storage_dir, pod.get_name());
@@ -234,7 +234,7 @@ containers:
 
         assert!(Path::new(&yaml_path).exists(), "YAML file was not created");
 
-        let content = fs::read_to_string(&yaml_path).expect("Failed to read YAML file");
+        let _content = fs::read_to_string(&yaml_path).expect("Failed to read YAML file");
 
         // Clean up
         fs::remove_file(&yaml_path).expect("Failed to remove YAML file after test");

src/agent/nodeagent/src/bluechi/mod.rs

@@ -31,7 +31,7 @@ pub async fn parse(yaml_str: String, nodename: String) -> common::Result<()> {
         parser::get_complete_model(package, nodename.clone(), models_str).await?;
     let pods: Vec<Pod> = models.into_iter().map(Pod::from).collect();
 
-    let _ = filemaker::make_files_from_pod(pods, nodename).await?;
+    filemaker::make_files_from_pod(pods, nodename).await?;
 
     // filemaker::delete_symlink_and_reload(&mi.get_name(), &model_node)
     // .await

src/agent/nodeagent/src/bluechi/parser.rs

@@ -19,7 +19,7 @@ pub async fn yaml_split(body: &str) -> common::Result<(String, Vec<Model>)> {
         let artifact_str = serde_yaml::to_string(&value)?;
 
         if let Some(kind) = value.clone().get("kind").and_then(|k| k.as_str()) {
-            let name: String = match kind {
+            let _name: String = match kind {
                 "Scenario" => serde_yaml::from_value::<Scenario>(value.clone())?.get_name(),
                 "Package" => serde_yaml::from_value::<Package>(value.clone())?.get_name(),
                 "Volume" => serde_yaml::from_value::<Volume>(value.clone())?.get_name(),
@@ -67,12 +67,32 @@ pub async fn get_complete_model(
     models: Vec<Model>,
 ) -> common::Result<Vec<Model>> {
     let mut base_models: Vec<Model> = Vec::new();
-    let mut model_name: String = String::new();
     for mi in p.get_models() {
         if mi.get_node() == node {
-            model_name = mi.get_name();
+            let model_name = mi.get_name();
             for model in models.iter() {
                 if model.get_name() == model_name {
+                    if let Some(volume_name) = mi.get_resources().get_volume() {
+                        let key = format!("Volume/{}", volume_name);
+                        let volume_str: String = common::etcd::get(&key).await?;
+                        let volume: Volume = serde_yaml::from_str(&volume_str)?;
+
+                        if let Some(volume_spec) = volume.get_spec() {
+                            model
+                                .get_podspec()
+                                .volumes
+                                .clone_from(volume_spec.get_volume());
+                        }
+                    }
+                    if let Some(network_name) = mi.get_resources().get_network() {
+                        let key = format!("Network/{}", network_name);
+                        let network_str = common::etcd::get(&key).await?;
+                        let network: Network = serde_yaml::from_str(&network_str)?;
+
+                        if let Some(_network_spec) = network.get_spec() {
+                            // TODO
+                        }
+                    }
                     base_models.push(model.clone());
                 } else {
                     println!("Model {} is not for this node {}", model.get_name(), node);
@@ -83,32 +103,6 @@ pub async fn get_complete_model(
             println!("Model {} is not for this node {}", mi.get_name(), node);
             continue;
         }
-        //let mut key = format!("Model/{}", mi.get_name());
-        //let base_model_str = common::etcd::get(&key).await?;
-        //let model: Model = serde_yaml::from_str(&base_model_str)?;
-
-        // if let Some(volume_name) = mi.get_resources().get_volume() {
-        //     key = format!("Volume/{}", volume_name);
-        //     let volume_str: String = common::etcd::get(&key).await?;
-        //     let volume: Volume = serde_yaml::from_str(&volume_str)?;
-
-        //     if let Some(volume_spec) = volume.get_spec() {
-        //         model
-        //             .get_podspec()
-        //             .volumes
-        //             .clone_from(volume_spec.get_volume());
-        //     }
-        // }
-
-        // if let Some(network_name) = mi.get_resources().get_network() {
-        //     key = format!("Network/{}", network_name);
-        //     let network_str = common::etcd::get(&key).await?;
-        //     let network: Network = serde_yaml::from_str(&network_str)?;
-
-        //     if let Some(network_spec) = network.get_spec() {
-        //         // TODO
-        //     }
-        //}
     }
     Ok(base_models)
 }
@@ -244,7 +238,9 @@ spec:
 
         // Deserialize and test
         let package: Package = serde_yaml::from_str(pkg_yaml).unwrap();
-        let result = get_complete_model(package).await;
+        let model: Model = serde_yaml::from_str(model_yaml).unwrap();
+        let models = vec![model];
+        let result = get_complete_model(package, "node1".to_string(), models).await;
 
         assert!(result.is_ok());
         let models = result.unwrap();
@@ -254,11 +250,32 @@ spec:
     // Test case for a valid scenario where get_complete_model works correctly
     #[tokio::test]
     async fn test_get_complete_model_success() {
+        let model_yaml = r#"
+apiVersion: v1
+kind: Model
+metadata:
+  name: helloworld-core
+  annotations:
+    io.piccolo.annotations.package-type: helloworld-core
+    io.piccolo.annotations.package-name: helloworld
+    io.piccolo.annotations.package-network: default
+  labels:
+    app: helloworld-core
+spec:
+  hostNetwork: true
+  containers:
+    - name: helloworld
+      image: helloworld
+  terminationGracePeriodSeconds: 0
+"#;
+
         // Create a dummy package with valid data
-        let package = extract_package_from_multi_yaml(VALID_ARTIFACT_YAML);
+        let package = extract_package_from_multi_yaml(VALID_ARTIFACT_YAML).unwrap();
+        let model: Model = serde_yaml::from_str(model_yaml).unwrap();
+        let models = vec![model];
 
         // Call get_complete_model and check if it returns Ok
-        let result = get_complete_model(package.expect("REASON")).await;
+        let result = get_complete_model(package, "HPC".to_string(), models).await;
 
         // If result is an error, print the error for debugging
         assert!(

src/agent/nodeagent/src/grpc/sender.rs

@@ -9,15 +9,10 @@ use common::statemanager::{
 use tonic::{Request, Status};
 
 /// Sender for making gRPC requests to Monitoring Server
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct NodeAgentSender {}
 
 impl NodeAgentSender {
-    /// Create a new NodeAgentSender
-    pub fn new() -> Self {
-        Self {}
-    }
-
     /// Trigger an action for a scenario
     pub async fn trigger_action(
         &mut self,

src/agent/nodeagent/src/main.rs

@@ -16,7 +16,7 @@ use tokio::sync::mpsc::{channel, Receiver, Sender};
 /// This function creates the manager, initializes it, and then runs it.
 /// If initialization or running fails, errors are printed to stderr.
 async fn launch_manager(rx_grpc: Receiver<HandleYamlRequest>, hostname: String) {
-    let mut manager = manager::NodeAgentManager::new(rx_grpc, hostname).await;
+    let manager = manager::NodeAgentManager::new(rx_grpc, hostname).await;
 
     //manager.initialize().await;
     let _ = manager.process_grpc_requests().await;
@@ -74,7 +74,7 @@ async fn main() {
 
 #[cfg(test)]
 mod tests {
-    use crate::{initialize, launch_manager};
+    use crate::launch_manager;
     use common::nodeagent::HandleYamlRequest;
     use tokio::sync::mpsc::{channel, Receiver, Sender};
     use tokio::task::LocalSet;

src/agent/nodeagent/src/manager.rs

@@ -29,7 +29,7 @@ impl NodeAgentManager {
     pub async fn new(rx: mpsc::Receiver<HandleYamlRequest>, hostname: String) -> Self {
         Self {
             rx_grpc: Arc::new(Mutex::new(rx)),
-            sender: Arc::new(Mutex::new(NodeAgentSender::new())),
+            sender: Arc::new(Mutex::new(NodeAgentSender::default())),
             hostname,
         }
     }

src/player/actioncontroller/src/grpc/receiver.rs

@@ -245,9 +245,8 @@ mod tests {
             scenario_name: "invalid_scenario".to_string(),
         });
 
-        let response = receiver.trigger_action(request).await.unwrap();
-        assert_eq!(response.get_ref().status, 1);
-        assert!(response.get_ref().desc.contains("Failed to trigger action"));
+        let response = receiver.trigger_action(request).await.unwrap_err();
+        assert!(response.message().contains("not found"));
     }
 
     #[tokio::test]

src/player/actioncontroller/src/runtime/bluechi/mod.rs

@@ -254,7 +254,7 @@ mod tests {
         assert_eq!(Command::UnitReload.to_method_name(), "ReloadUnit");
 
         let unknown_cmd = Command::ControllerReloadAllNodes;
-        assert_eq!(unknown_cmd.to_method_name(), "Unknown");
+        assert_eq!(unknown_cmd.to_method_name(), "ReloadAllNodes");
     }
 
     // ------------------- NEGATIVE TESTS -------------------