no buggs now

src/main.rs

@@ -14,40 +14,40 @@ enum CustomError {
     Fatal,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 struct Processes {
     #[serde(default)]
     processes : Vec<TrackingProcess>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 struct TrackingProcess {
     name : String, 
     path : String,
     dependencies: Dependencies,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 struct Dependencies {
     #[serde(default)]
     files : Vec<Files>,
     #[serde(default)]
     services: Vec<Services>,
 }
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 struct Files {
     filename : String,
     src : String, 
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 struct Services {
     hostname : String,
     port :  u32,
     triggers : ServiceTriggers,
 } 
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 struct ServiceTriggers {
     wait : u32, 
     delay: u32,
@@ -63,8 +63,6 @@ async fn main() {
         return;
     }
     let mut handler: Vec<tokio::task::JoinHandle<()>> = vec![];
-    let mut proc_clone: &TrackingProcess;
-    let mut tx_clone: mpsc::Sender<usize>;
 
     for proc in processes.processes.iter() {
         println!("\nProcess '{}' on stage:\n{}\nDepends on {} file(s), {} service(s)\n",
@@ -94,10 +92,10 @@ async fn main() {
             return;
         }
 
-        proc_clone = proc.clone();
+        let proc_clone = proc.clone();
-        tx_clone = tx.clone();
+        let tx_clone = tx.clone();
         let event = tokio::spawn(async move {
-            run_daemons(proc_clone, tx_clone, &mut rx).await;
+            run_daemons(&proc_clone, tx_clone, &mut rx).await;
         });
         handler.push(event);
     }
@@ -114,8 +112,8 @@ async fn run_daemons(
 ) {
     
     let run_hand = running_handler(&proc.name, &proc.path, tx.clone());
-    let file_hand = file_handler(&proc.dependencies.files, tx.clone());
+    let file_hand = file_handler(&proc.name,&proc.dependencies.files, tx.clone());
-    let serv_hand = service_handler(&proc.dependencies.services, tx.clone());
+    let serv_hand = service_handler(&proc.name, &proc.dependencies.services, tx.clone());
 
     tokio::select! {
         _ = run_hand => {},
@@ -182,9 +180,12 @@ async fn running_handler(name: &str, path: &str, tx: mpsc::Sender<usize>){
     }
 }
 
-async fn file_handler(files: &Vec<Files>, tx: mpsc::Sender<usize>) {
+async fn file_handler(name: &str, files: &Vec<Files>, tx: mpsc::Sender<usize>) {
     loop {
         for file in files {
+            if !is_active(name) {
+                break;
+            }
             match check_file(&file.filename, &file.src) {
                 Ok(_) => {
                     println!("{} is still in directory!", &file.filename);
@@ -207,9 +208,12 @@ fn check_file(filename: &str, path: &str) -> Result<(), CustomError> {
     }
 }
 
-async fn service_handler(services: &Vec<Services>, tx: mpsc::Sender<usize>) {
+async fn service_handler(name: &str, services: &Vec<Services>, tx: mpsc::Sender<usize>) {
     loop {
         for serv in services {
+            if !is_active(name) {
+                break;
+            }
             match check_service(&serv.hostname, &serv.port) {
                 Ok(_) => {
                     println!("{} is up!", &serv.hostname);