Event dispatching

src/main.rs

@@ -1,15 +1,16 @@
-extern crate libloading;
 mod message;
 mod monitor;
 mod output;
 mod plugins;
 
-// use libloading::{Library, Symbol};
+use std::thread;
+use std::sync::mpsc;
 
 use crate::monitor::Monitor;
 use crate::output::Output;
 use crate::message::Message;
 
+
 fn main() {
     // let lib = Library::new("/home/crom/.gitprojects/rnetmon/plugins/output/stdout/target/debug/deps/libstdout.so").unwrap();
 
@@ -17,17 +18,53 @@ fn main() {
     //     let handle_message: Symbol<unsafe fn()> = lib.get(b"handle_message").unwrap();
     //     handle_message();
     // }
+    // let msg = Message{
+    // 	emitter: "me".to_string(),
+    // 	level: 10,
+    // 	msg_type: "string".to_string(),
+    // 	text: "Consectetur duis do dolor deserunt est minim dolore tempor et non duis.".to_string(),
+    // };
+    let (mon_sender, mon_receiver) = mpsc::channel();
 
-    let msg = Message{
-    	emitter: "me".to_string(),
-    	level: 10,
-    	msg_type: "string".to_string(),
-    	text: "Consectetur duis do dolor deserunt est minim dolore tempor et non duis.".to_string(),
-    };
+    // let mut monitors: Vec<(Box<Monitor>, thread::JoinHandle<_>)> = vec![];
+    let mut monitor_threads: Vec<thread::JoinHandle<_>> = vec![];
+    {
+        let snd = mon_sender.clone();
+        let mon = plugins::monitor::tester::Tester::new();
+        let thread = thread::spawn(move|| {
+            loop {
+                mon.run(&snd);
+            }
+        });
+        monitor_threads.push(thread)
+        // monitor_threads.push((mon, thread));
+    }
+    let monitor_threads = monitor_threads;
 
-    let input = plugins::monitor::tester::Tester::new();
 
-    let out = plugins::output::stdout::Stdout::new();
-    out.on_message(&msg);
+    let mut output_senders: Vec<mpsc::Sender<Message>> = vec![];
+    let mut output_threads: Vec<thread::JoinHandle<_>> = vec![];
+    {
+        let (out_sender, out_receiver) = mpsc::channel();
+        output_senders.push(out_sender);
+
+        let thread = thread::spawn(move|| {
+            loop {
+                let message = out_receiver.recv().unwrap();
+                println!("{:?}", message);
+            }
+        });
+        output_threads.push(thread);
+    }
+    let output_senders = output_senders;
+    let output_threads = output_threads;
+
+    // Dispatch messages
+    loop {
+        let message = mon_receiver.recv().unwrap();
+        for out in &output_senders {
+            out.send(message.clone()).unwrap();
+        }
+    }
 
 }

src/message.rs

@@ -1,9 +1,21 @@
 
 
 #[derive(Debug)]
+#[derive(Clone)]
 pub struct Message {
 	pub emitter: String,
 	pub level: i32,
 	pub msg_type: String,
 	pub text: String,
-}
+}
+
+// impl Clone for Message {
+// 	fn clone(&self) -> Self {
+// 		Message{
+// 			emitter: self.emitter.clone(),
+// 			level: self.level,
+// 			msg_type: self.msg_type.clone(),
+// 			text: self.text.clone(),
+// 		}
+// 	}
+// }

src/monitor.rs

@@ -1,7 +1,9 @@
 
 use crate::message::Message;
 
+pub use std::sync::mpsc;
+
 pub trait Monitor {
-    fn new() -> Self;
-    fn run(&self);
+    fn new() -> Self where Self: Sized;
+    fn run(&self, sender: &mpsc::Sender<Message>);
 }

src/output.rs

@@ -1,7 +1,8 @@
 
 use crate::message::Message;
+use std::sync::mpsc;
 
 pub trait Output {
-	fn new() -> Self;
-    fn on_message(&self, message: &Message);
+	fn new(receiver: mpsc::Receiver<Message>) -> Self;
+    fn on_message(&self, message: Message);
 }

src/plugins/monitor/tester.rs

@@ -1,6 +1,8 @@
 
-use crate::message::Message;
 pub use crate::monitor::Monitor;
+pub use crate::message::Message;
+pub use std::sync::mpsc;
+
 
 #[derive(Debug)]
 pub struct Tester {
@@ -11,7 +13,19 @@ impl Monitor for Tester {
 	fn new() -> Self {
 		Tester{}
 	}
-	fn run(&self) {
+	fn run(&self, sender: &mpsc::Sender<Message>) {
+
+		loop {
+			println!("-- Sending message");
+			sender.send(Message{
+				emitter: "me".to_string(),
+				level: 10,
+				msg_type: "string".to_string(),
+				text: "Consectetur duis do dolor deserunt est minim dolore tempor et non duis.".to_string(),
+			}).unwrap();
+
+			std::thread::sleep(std::time::Duration::from_millis(2000));
+		}
 
 	}
 }

src/plugins/output/stdout.rs

@@ -1,18 +1,20 @@
 
 use crate::message::Message;
 pub use crate::output::Output;
+use std::sync::mpsc;
 
 #[derive(Debug)]
 pub struct Stdout {
-
+	receiver: mpsc::Receiver<Message>,
 }
 
 impl Output for Stdout {
-	fn new() -> Self {
-		Stdout{}
+	fn new(receiver: mpsc::Receiver<Message>) -> Self {
+		Stdout{
+			receiver: receiver
+		}
 	}
+	fn on_message(&self, message: Message){
 
-	fn on_message(&self, message: &Message){
-		println!("{:?}", message);
 	}
 }