Merge branch 'timeout' into new_events

boringtun

@@ -1 +1 @@
-Subproject commit cabd96987454add6785c6363e4846ef1ff09101e
+Subproject commit 1f842a618a4efb460841a3e0104f4979b21a2485

wg-event-gen/src/gen.rs

@@ -30,23 +30,9 @@ pub(crate) fn gen_events(
                     }
                 }
 
-                let timedout_now = || {
-                    if let Some(shake) = cur.last_handshake {
-                        if let Ok(el) = shake.elapsed() {
-                            return el > timeout && el + poll_interval < timeout;
-                        }
-                    }
-                    true
-                };
+                let timedout_now = || !cur.last_handshake.is_some();
 
-                let timedout_prev = || {
-                    if let Some(shake) = prev.last_handshake {
-                        if let Ok(el) = shake.elapsed().map(|el| el - poll_interval) {
-                            return el > timeout && el < timeout + poll_interval;
-                        }
-                    }
-                    true
-                };
+                let timedout_prev = || !prev.last_handshake.is_some();
 
                 match (
                     timedout_prev(),

wg-event-gen/src/main.rs

@@ -17,9 +17,10 @@ use controller::Userspace;
 use model::WireguardController;
 use opts::Opts;
 use std::collections::HashMap;
+use std::error::Error;
 use std::io;
 use std::thread::sleep;
-use std::time::{Duration, SystemTime,Instant, UNIX_EPOCH};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use structopt::StructOpt;
 
 fn listeners(opts: &Opts) -> Vec<Box<EventListener>> {
@@ -30,6 +31,7 @@ fn listeners(opts: &Opts) -> Vec<Box<EventListener>> {
     if opts.log {
         listeners.push(Box::new(LogListener));
     }
+    println!("Enabled handlers: {}", (&listeners.iter().map(|l| l.name()).collect::<Vec<_>>()).join(", "));
     listeners
 }
 
@@ -46,33 +48,23 @@ fn main() -> io::Result<()> {
         interval
     );
     let mut peers_last: Option<HashMap<ECCKey, Peer>> = None;
-    let start = SystemTime::now();
     loop {
         let now = Instant::now();
-        let peers = controller.peers()?;
-        /*println!("Connected peers:");
-        for peer in peers {
-            let peer = peer?;
-            if peer
-                .last_handshake
-                .map(|h| h.elapsed().unwrap() < timeout)
-                .unwrap_or(false)
-            {
-                println!("/\\{:?}  {}",(timeout - peer.last_handshake.unwrap().elapsed().unwrap()), peer);
+        let peers = match controller.peers() {
+            Err(ref err) if opts.ignore_socket_errors => {
+                eprintln!(
+                    "Encountered error while querying Wireguard: {}",
+                    err.description()
+                );
+                sleep(interval);
+                continue;
             }
-        }*/
+            res => res?,
+        };
         let peers = peers
             .map(|peer| peer.map(|peer_ok| (peer_ok.key.clone(), peer_ok)))
             .collect::<io::Result<HashMap<_, _>>>()?;
-        for (k, p) in peers.iter() {
-            if let Some(shake) = p.last_handshake {
-                println!(
-                    "{} {:?}",
-                    k.to_string()[0..5].to_string(),
-                    shake.duration_since(start).unwrap()
-                );
-            }
-        }
+
         if let Some(ref mut peers_last) = peers_last {
             gen_events(&peers, &peers_last, &listeners, timeout, interval);
 
@@ -81,7 +73,7 @@ fn main() -> io::Result<()> {
             peers_last = Some(peers);
         }
         let pause = interval - now.elapsed();
-        dbg!(interval - pause);
+
         sleep(if pause > interval / 2 {
             pause
         } else {