basic strcuture [CI SKIP]

wg-event-gen/src/controller.rs

@@ -1,6 +1,9 @@
-use crate::model::WireguardController;
+use crate::model::{ECCKey, Peer, PeerBuilder, WireguardController};
+use std::io::{BufRead, BufReader, Result, Write};
+use std::net::{IpAddr, SocketAddr};
 use std::os::unix::net::UnixStream;
 use std::path::PathBuf;
+use std::time::Duration;
 
 pub struct Userspace(PathBuf);
 
@@ -11,36 +14,50 @@ impl Userspace {
 }
 
 impl WireguardController for Userspace {
-    fn peers<'a>(&'a mut self) -> Box<Iterator<Item = Result<Peer>> + 'a> {
+    fn peers<'a>(&'a mut self) -> Result<Box<Iterator<Item = Result<Peer>> + 'a>> {
         let mut stream = UnixStream::connect(&self.0)?;
         stream.write_all(b"get=1\n")?;
 
-        fn build_peer(builder: &mut PeerBuilder, line: String) -> Result<()> {
+        fn build_peer(builder: &mut PeerBuilder, line: io::Result<String>) -> Option<Result<Peer>> {
             let line = line?;
             let mut iter = line.chars();
             let key = iter.by_ref().take_while(|c| c != &'=').collect::<String>();
             let value = iter.collect::<String>();
-            let mut allowed_ips: Vec<(IpAddr, u8)> = Vec::new();
-            let mut last_handshake: Option<Duration> = None;
+            let mut ips: Vec<(IpAddr, u8)> = Vec::with_capacity(0);
+            if builder.allowed_ips.len() > 1 {
+                ips.append(&builder.allowed_ips);
+            }
             let update_handshake = |d: Duration| {
-                last_handshake = last_handshake.map(|c| c + d);
+                builder.last_handshake(last_handshake.map(|c| c + d));
+            };
+            let value_as_num = || value.parse::<usize>();
+            let mut peer: Option<Peer> = None;
+            let add_key = |key| {
+                if builder.key.is_some() {
+                    //If next entry begins
+                    peer = Some(builder.build().map_err(|err: String| {
+                        io::Error::new(ErrorKind::InvalidData, err.into())
+                    })?);
+                    *builder = PeerBuilder::default();
+                }
+                builder.key(key);
             };
             match key.as_ref() {
-                "public_key" => builder.key(ECCKey::from_base64(value)?),
-                "private_key" => builder.key(ECCKey::from_base64(value)?),
-                "endpoint" => builder.endpoint(value::parse::<SocketAddr>()?),
+                "public_key" => add_key(ECCKey::from_base64(value)?),
+                "private_key" => add_key(ECCKey::from_base64(value)?),
+                "endpoint" => builder.endpoint(value.parse::<SocketAddr>()?),
                 "last_handshake_time_sec" => {
-                    update_handshake(Duration::from_secs(value::parse::<usize>().into()))
+                    update_handshake(Duration::from_secs(value_as_num().into()));
                 }
                 "last_handshake_time_nsec" => {
-                    update_handshake(Duration::from_nsecs(value::parse::<usize>().into()))
+                    update_handshake(Duration::from_nanos(value_as_num().into()));
                 }
                 "persistent_keepalive" => {
-                    builder.keepalive(Duration::from_secs(value::parse::<usize>().into()))
+                    builder.persistent_keepalive(Some(Duration::from_secs(value_as_num().into())));
                 }
                 "allowed_ip" => {
                     let mut parts = value.split("/").into_iter();
-                    let ip = match (
+                    let net = match (
                         parts.next().and_then(|addr| addr.parse::<IpAddr>().ok()),
                         parts.next().and_then(|mask| mask.parse::<u8>().ok()),
                     ) {
@@ -49,17 +66,18 @@ impl WireguardController for Userspace {
                         (Some(addr), None) => Some((addr, 32)),
                         _ => None,
                     };
-                    ips.push(ip);
+                    if let Some(net) = net {
+                        builder.allowed_ips.map(|ips| ips.push(net));
+                    }
                 }
             }
-            builder.allowed_ips(ips);
-            builder.last_handshake(last_handshake);
+            peer.map(|peer| Ok(peer))
         }
 
         let peers = BufReader::new(stream)
             .lines()
             .scan(PeerBuilder::default(), build_peer);
-        loop {}
+        Ok(Box::new(peers))
     }
 
     fn update_peer(&mut self, peer: &Peer) -> Result<()> {