Merge pull request #79 from plx-pdg/feat-app-initialization

feat: app initialization

src/core/app.rs

@@ -4,7 +4,7 @@ use std::sync::{
 };
 
 use crate::{
-    models::{event::Event, exo::Exo, project::Project, ui_state::UiState},
+    models::{event::Event, exo::Exo, key::Key, project::Project, ui_state::UiState},
     ui::ui::Ui,
 };
 
@@ -23,6 +23,7 @@ pub struct App {
     event_tx: Sender<Event>,
     event_rx: Receiver<Event>,
     ui_state_tx: Sender<UiState>,
+    run: bool,
 }
 
 impl App {
@@ -51,11 +52,33 @@ impl App {
             event_tx,
             event_rx,
             ui_state_tx,
+            run: true,
         };
         app.start_ui(ui_state_rx);
         Ok(app)
     }
-
+    pub fn run_forever(mut self) {
+        while self.run {
+            if let Ok(event) = self.event_rx.recv() {
+                match event {
+                    Event::KeyPressed(Key::Q) => {
+                        self.run = false;
+                        if let Ok(mut wh) = self.work_handler.lock() {
+                            wh.stop_all_workers_and_wait();
+                        }
+                    }
+                    Event::KeyPressed(_) => todo!(),
+                    Event::EditorOpened => todo!(),
+                    Event::CouldNotOpenEditor => todo!(),
+                    Event::ProcessCreationFailed => todo!(),
+                    Event::ProcessOutputLine(_) => todo!(),
+                    Event::OutputCheckPassed(_) => todo!(),
+                    Event::OutputCheckFailed(_, _) => todo!(),
+                    Event::FileSaved => todo!(),
+                }
+            }
+        }
+    }
     fn start_work(&mut self, work: Box<dyn Work + Send>) {
         if let Ok(mut work_handler) = self.work_handler.lock() {
             work_handler.spawn_worker(work);

src/core/work/work_handler.rs

@@ -10,7 +10,11 @@ use std::{
 
 use crate::models::event::Event;
 
-use super::{work::Work, work_type::WorkType, worker::Worker};
+use super::{
+    work::Work,
+    work_type::WorkType,
+    worker::{self, Worker},
+};
 
 pub(crate) enum WorkEvent {
     Done(usize),
@@ -104,12 +108,21 @@ impl WorkHandler {
             .for_each(|(_, worker)| worker.stop());
         self.workers.retain(|_, worker| worker.work != work_type);
     }
-    pub fn stop_all_workers(&mut self) {
+    fn stop_all_workers(&mut self) {
         self.workers
             .iter_mut()
             .for_each(|(_, worker)| worker.stop());
-        self.workers.clear();
     }
+
+    pub fn stop_all_workers_and_wait(&mut self) {
+        self.stop_all_workers(); // Signal every worker to stop
+        let workers: Vec<_> = self.workers.drain().map(|(_, worker)| worker).collect();
+
+        for worker in workers {
+            worker.join(); // join here
+        }
+    }
+
     fn remove_worker(&mut self, id: usize) {
         self.workers.remove(&id);
     }
@@ -204,6 +217,34 @@ mod tests {
             for flag in stop_flags {
                 assert!(flag.load(Ordering::Relaxed));
             }
+            assert_eq!(handler.workers.len(), 10);
+        };
+    }
+
+    #[test]
+    fn test_stop_all_workers_wait() {
+        let (tx, _) = channel();
+        let handler = WorkHandler::new(tx.clone());
+
+        if let Ok(mut handler) = handler.lock() {
+            let range = 10;
+            for _ in 0..range {
+                let _ = handler.spawn_worker(Box::new(EditorOpener::new(
+                    "echo".to_string(),
+                    "null".into(),
+                )));
+            }
+            let stop_flags: Vec<Arc<AtomicBool>> = handler
+                .workers
+                .values()
+                .into_iter()
+                .map(|work_info| work_info.should_stop.clone())
+                .collect();
+            assert_eq!(handler.workers.len(), range);
+            handler.stop_all_workers_and_wait();
+            for flag in stop_flags {
+                assert!(flag.load(Ordering::Relaxed));
+            }
             assert_eq!(handler.workers.len(), 0);
         };
     }

src/main.rs

@@ -1,7 +1,14 @@
+use core::app::App;
+
 pub mod core;
 pub mod models;
 pub mod ui;
 
 fn main() {
-    println!("Waiting on core and UI init");
+    match App::new() {
+        Ok(app) => app.run_forever(),
+        Err(err) => {
+            eprintln!("Error starting plx {err}");
+        }
+    }
 }