new event system [CI SKIP]

wg-event-gen/src/gen.rs

@@ -26,7 +26,7 @@ pub(crate) fn gen_events(
             (Some(prev), Some(cur)) => {
                 if let (Some(prev_addr), Some(cur_addr)) = (prev.endpoint, cur.endpoint) {
                     if prev_addr != cur_addr {
-                        listeners.roaming(&cur, prev_addr);
+                        listeners.fire(Event::Roamed(&cur, prev_addr));
                     }
                 }
 
@@ -48,14 +48,23 @@ pub(crate) fn gen_events(
                     true
                 };
 
-                match (timedout_prev(), timedout_now()) {
+                match (
-                    (false, true) => listeners.disconnected(&cur),
+                    timedout_prev(),
-                    (true, false) => listeners.connected(&cur),
+                    timedout_now(),
-                    other => (),
+                    prev.last_handshake.and_then(|p_shake| {
+                        cur.last_handshake
+                            .and_then(|c_shake| c_shake.duration_since(p_shake).ok())
+                    }),
+                ) {
+                    (false, true, _) => listeners.fire(Event::Disconnected(&cur)),
+                    (true, false, _) => listeners.fire(Event::Connected(&cur)),
+                    other => {
+                        //dbg!(other);
                     }
                 }
-            (None, Some(cur)) => listeners.added(&cur),
+            }
-            (Some(prev), None) => listeners.removed(&prev),
+            (None, Some(cur)) => listeners.fire(Event::Added(&cur)),
+            (Some(prev), None) => listeners.fire(Event::Removed(&prev)),
             fail => {
                 println!("{:?}", fail);
                 unreachable!()

wg-event-gen/src/listener.rs

@@ -5,74 +5,43 @@ use std::process::Command;
 use std::thread;
 use std::time::SystemTime;
 
+//#[non_exhaustive]
+#[derive(Debug, Clone)]
+pub enum Event<'a> {
+    Added(&'a Peer),
+    Removed(&'a Peer),
+    Connected(&'a Peer),
+    Disconnected(&'a Peer),
+    Roamed(&'a Peer, SocketAddr),
+}
+
 pub trait EventListener {
-    fn added<'a>(&self, peer: &'a Peer) {
+    fn fire<'a>(&self, event: Event<'a>);
-        self.connected(peer);
-    }
-
-    fn connected<'a>(&self, peer: &'a Peer);
-
-    fn disconnected<'a>(&self, peer: &'a Peer);
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        self.disconnected(peer)
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr);
 }
 
 impl EventListener for Vec<Box<EventListener>> {
-    fn added<'a>(&self, peer: &'a Peer) {
+    fn fire<'a>(&self, event: Event<'a>) {
-        if cfg!(feature = "addrem") || cfg!(test) {
+        self.iter().for_each(|l| l.fire(event.clone()));
-            self.iter().for_each(|l| l.added(&peer));
-        }
-    }
-
-    fn connected<'a>(&self, peer: &'a Peer) {
-        self.iter().for_each(|l| l.connected(&peer));
-    }
-
-    fn disconnected<'a>(&self, peer: &'a Peer) {
-        self.iter().for_each(|l| l.disconnected(&peer));
-    }
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        if cfg!(feature = "addrem") || cfg!(test) {
-            self.iter().for_each(|l| l.removed(&peer));
-        }
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
-        self.iter().for_each(|l| l.roaming(&peer, previous_addr));
     }
 }
 
 pub struct LogListener;
 
 impl EventListener for LogListener {
-    fn connected<'a>(&self, peer: &'a Peer) {
+    fn fire<'a>(&self, event: Event<'a>) {
-        println!("{} connected!", peer.key);
+        match event {
-    }
+            Event::Connected(peer) => println!("{} connected!", peer.key),
-
+            Event::Disconnected(peer) => println!("{} disconnected!", peer.key),
-    fn disconnected<'a>(&self, peer: &'a Peer) {
+            Event::Added(peer) => println!("{} added!", peer.key),
-        println!("{} disconnected!", peer.key);
+            Event::Removed(peer) => println!("{} removed!", peer.key),
-    }
+            Event::Roamed(peer, previous_addr) => println!(
-
-    fn added<'a>(&self, peer: &'a Peer) {
-        println!("{} added!", peer.key);
-    }
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        println!("{} removed!", peer.key);
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
-        println!(
                 "{} roamed {} -> {}!",
                 peer.key,
                 previous_addr,
                 peer.endpoint.unwrap()
-        );
+            ),
+            _ => unimplemented!(),
+        }
     }
 }
 
@@ -134,27 +103,20 @@ impl ScriptListener {
 }
 
 impl EventListener for ScriptListener {
-    fn connected<'a>(&self, peer: &'a Peer) {
+    fn fire<'a>(&self, event: Event<'a>) {
-        self.call_sub(vec!["connected", &self.peer_props(peer)]);
+        match event {
+            Event::Connected(peer) => self.call_sub(vec!["connected", &self.peer_props(peer)]),
+            Event::Disconnected(peer) => {
+                self.call_sub(vec!["disconnected", &self.peer_props(peer)])
             }
-
+            Event::Added(peer) => self.call_sub(vec!["added", &self.peer_props(peer)]),
-    fn disconnected<'a>(&self, peer: &'a Peer) {
+            Event::Removed(peer) => self.call_sub(vec!["removed", &self.peer_props(peer)]),
-        self.call_sub(vec!["disconnected", &self.peer_props(peer)]);
+            Event::Roamed(peer, previous_addr) => self.call_sub(vec![
-    }
-
-    fn added<'a>(&self, peer: &'a Peer) {
-        self.call_sub(vec!["added", &self.peer_props(peer)]);
-    }
-
-    fn removed<'a>(&self, peer: &'a Peer) {
-        self.call_sub(vec!["removed", &self.peer_props(peer)]);
-    }
-
-    fn roaming<'a>(&self, peer: &'a Peer, previous_addr: SocketAddr) {
-        self.call_sub(vec![
                 "roaming",
                 &self.peer_props(peer),
                 &previous_addr.to_string(),
-        ]);
+            ]),
+            _ => unimplemented!(),
+        }
     }
 }