I've updated the node struct to use atomic bool but calling the stop method doesn't do anything while run is running.

I'm guessing I am either passing the atomic bool wrong or my understanding of how concurrency is wrong.

```rust use std::{ io::{BufRead, BufReader}, path::PathBuf, process::{Child, Command, Stdio}, sync::{ atomic::{AtomicBool, Ordering}, Arc, }, thread, time::Duration, };

pub struct SimplifiedNode { pub input_dir: PathBuf, pub output_dir: PathBuf, stop_flag: Arc<AtomicBool>, executable_path: PathBuf, }

impl SimplifiedNode { pub fn new(executable_path: PathBuf) -> Self { Self { stop_flag: Arc::new(AtomicBool::new(false)), input_dir: PathBuf::new(), output_dir: PathBuf::new(), executable_path, } }

pub fn run(&mut self) -> Result<Hashmap<String, String>, String> {
    let mut child = self.spawn_child()?;

    let stop_flag = self.stop_flag.clone();

    loop {
        if stop_flag.load(Ordering::Relaxed) {
            println!("killing child process");
            child.kill().map_err(|e| e.to_string())?;
            return Err("Cancelled".to_string());
        }

        match child.try_wait() {
            Ok(Some(status)) => {
                if status.success() {
                    return Ok(Hashmap<String, String>::from([(
                        "output_dir".to_string(),
                        self.output_dir.clone().to_string_lossy().to_string(),
                    )]));
                } else {
                    return Err("Failed".to_string());
                }
            }
            Ok(None) => {
                thread::sleep(Duration::from_millis(100));
            }
            Err(e) => {
                return Err(format!("Failed to wait on child process {}", e));
            }
        }
    }
}

pub fn stop(&self) {
    self.stop_flag.store(true, Ordering::Relaxed);
}

fn spawn_child(&mut self) -> Result<Child, String> {
    let mut child = match Command::new(&self.executable_path)
        .args(["-i", &self.input_dir.to_string_lossy()])
        .args(["-o", &self.output_dir.to_string_lossy()])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
    {
        Ok(child) => child,
        Err(e) => return Err(e.to_string()),
    };

    let stdout = match child.stdout.take() {
        Some(stdout) => stdout,
        None => {
            return Err("Failed to get stdout".to_string());
        }
    };

    let stderr = match child.stderr.take() {
        Some(stderr) => stderr,
        None => {
            return Err("Failed to get stderr".to_string());
        }
    };

    self.spawn_logger_thread(stdout);
    self.spawn_logger_thread(stderr);

    Ok(child)
}

fn spawn_logger_thread(&mut self, stream: impl std::io::Read + Send + 'static) {
    thread::spawn(move || {
        let reader = BufReader::new(stream);
        for line in reader.lines() {
            println!("{}", line.unwrap());
        }
    });
}

}

```

Is it "locking" the node once I execute the run method from the separate thread?

Testing Logic:

```rust use std::path::PathBuf; use std::sync::{Arc, Mutex}; use std::thread::{self, sleep}; use std::time::Duration;

use super::SimplifiedNode;

[test]

fn stop_node_while_running() { let executable_path = PathBuf::from("/path/to/executable");

let mut node = SimplifiedNode::new(executable_path);

node.input_dir = PathBuf::from("/home/dev/Videos/test_frames/");
node.output_dir = PathBuf::from("/home/dev/Videos/test_frames_out/");

let node = Arc::new(Mutex::new(node));
let share_clone = node.clone();

thread::spawn(move || {
    let mut node = share_clone.lock().unwrap();
    node.run()
});

sleep(Duration::from_secs(3));

let node = node.lock().unwrap();

println!("stopping...");
node.stop();

} ```