move main engine in worker

src/worker/mod.rs

@@ -1 +1,3 @@
 mod worker;
+
+pub use worker::{Manager, Queue};

src/worker/worker.rs

@@ -1,35 +1,25 @@
 use std::collections::VecDeque;
 use std::sync::{Arc, Condvar, Mutex};
 use std::thread;
-use std::time;
-use std::time::Duration;
 
-use crate::message::Message;
 use crate::model::*;
-use crate::queue::QueueStatus;
 
-struct Queue<T: Runner> {
+pub struct Queue<T> {
     content: Mutex<VecDeque<T>>,
     not_empty: Condvar,
 }
 
-impl<T: Runner> Queue<T> {
-    fn new() -> Self {
+impl<T> Queue<T> {
+    pub fn new() -> Self {
         Self {
-            content: Mutex::new(VecDeque::new()),
+            content: Mutex::new(VecDeque::<T>::new()),
             not_empty: Condvar::new(),
         }
     }
-
-    pub fn add_runner(&self, runner: T) {
-        let mut c = self.content.lock().unwrap();
-        c.push_back(runner);
-
-        self.not_empty.notify_one();
-    }
 }
 
 #[derive(Copy, Clone, PartialEq)]
+#[allow(dead_code)]
 pub enum WorkerStatus {
     Pending,
     Running,
@@ -51,36 +41,34 @@ impl Worker {
         self.status = status;
     }
 
+    #[allow(dead_code)]
     fn get_status(&self) -> WorkerStatus {
         self.status
     }
 }
 
-pub struct Manager {
+pub struct Manager<T: Runner> {
     name: String,
     workers: Vec<Arc<Mutex<Worker>>>,
+    queue: Arc<Queue<T>>,
 }
 
-impl Manager {
-    fn new(name: &str) -> Self {
+impl<T: Runner + std::marker::Send + 'static> Manager<T> {
+    pub fn new(name: &str) -> Self {
         Self {
             name: name.to_string(),
             workers: vec![],
+            queue: Arc::new(Queue::<T>::new()),
         }
     }
 
-    fn launch_workers<T: Runner + std::marker::Send + 'static>(
-        &mut self,
-        nb_workers: u32,
-        shared_queue: Arc<Queue<T>>,
-    ) {
+    pub fn launch_workers(&mut self, nb_workers: u32) {
         for i in 0..nb_workers {
             let shared_worker = Arc::new(Mutex::new(Worker::new()));
-
             self.workers.push(shared_worker.clone());
 
             let worker = shared_worker.clone();
-            let queue = shared_queue.clone();
+            let queue = self.queue.clone();
             let name = self.name.clone();
 
             thread::spawn(move || loop {
@@ -102,6 +90,7 @@ impl Manager {
 
                 println!("[worker({} - {})] launching job...", name, i);
                 runner.run();
+                println!("[worker({} - {})] job done", name, i);
 
                 let mut guard = worker.lock().unwrap();
                 guard.set_status(WorkerStatus::Pending);
@@ -110,6 +99,14 @@ impl Manager {
         }
     }
 
+    pub fn add_runner(&self, runner: T) {
+        let mut q = self.queue.content.lock().unwrap();
+        q.push_back(runner);
+
+        self.queue.not_empty.notify_one();
+    }
+
+    #[allow(dead_code)]
     fn healthcheck(&self, target: WorkerStatus) -> bool {
         for w in &self.workers {
             if w.lock().unwrap().get_status() != target {
@@ -119,29 +116,3 @@ impl Manager {
         true
     }
 }
-
-#[test]
-fn test_manager() {
-    use std::time;
-    use std::time::Duration;
-
-    let mut m = Manager::new("deploy");
-    let queue_deploy = Arc::new(Queue::<Job>::new());
-    let queue_check = Arc::new(Queue::<Job>::new());
-
-    m.launch_workers(5, queue_deploy.clone());
-
-    assert_eq!(5, m.workers.len());
-    assert!(!m.healthcheck(WorkerStatus::Failed));
-
-    for i in 0..500 {
-        let j = Job::new(i, JobAction::MegaportDeploy);
-
-        queue_deploy.add_runner(j);
-    }
-
-    let wait = time::Duration::from_millis(200);
-    thread::sleep(wait);
-
-    assert!(m.healthcheck(WorkerStatus::Pending));
-}