Use Result<> for Peer::new()

2 files changed, 13 insertions, 17 deletions

diff --git a/src/main.rs b/src/main.rs
index 0b652bb..25ef860 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -227,7 +227,7 @@ fn do_add(conf: &mut WireguardConfig, conf_path: String, peer_name: &String, ip:
         None => {}
     }
 
-    let p = wg::peer::Peer::new(peer_name.clone(), ip);
+    let p = wg::peer::Peer::new(peer_name.clone(), ip)?;
     conf.peers.push(p);
 
     let mut f = File::create(conf_path)?;
diff --git a/src/wg/peer.rs b/src/wg/peer.rs
index 17722e5..c374ca0 100644
--- a/src/wg/peer.rs
+++ b/src/wg/peer.rs
@@ -6,7 +6,7 @@ use std::path::{Path};
 use std::process::{Command, Stdio};
 use std::io::Write as ioWrite;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 
 use super::config::WireguardConfig;
 
@@ -18,30 +18,30 @@ pub struct Peer {
 }
 
 impl Peer {
-    pub fn new(name: String, ip: Ipv4Addr) -> Peer {
+    pub fn new(name: String, ip: Ipv4Addr) -> Result<Peer> {
         let private = Command::new("wg")
             .arg("genkey")
             .output()
-            .expect("Could not generate a private key. Is 'wg' installed?");
+            .context("Could not generate a private key. Is 'wg' installed?")?;
 
         let mut public = Command::new("wg")
             .arg("pubkey")
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .spawn()
-            .expect("Could not run 'wg'");
+            .context("Could not run 'wg'")?;
 
         let private_clone = private.stdout.clone();
 
-        let mut stdin = public.stdin.take().expect("could not open wg stdin");
+        let mut stdin = public.stdin.take().context("could not open wg stdin")?;
         std::thread::spawn(move || {
             stdin.write_all(&private.stdout).unwrap();
         });
 
-        let output = public.wait_with_output().expect("could not read from 'wg pubkey'");
+        let output = public.wait_with_output().context("could not read from 'wg pubkey'")?;
     
-        let private_key = String::from_utf8(private_clone).expect("could not decode private key");
-        let public_key = String::from_utf8(output.stdout).expect("could not decode public key");
+        let private_key = String::from_utf8(private_clone).context("could not decode private key")?;
+        let public_key = String::from_utf8(output.stdout).context("could not decode public key")?;
 
         let private_key = private_key.trim();
         let public_key = public_key.trim();
@@ -52,15 +52,11 @@ impl Peer {
             public_key: String::from(public_key)
         };
 
-        let mut f = match File::create(p.private_key_path()) {
-            Ok(f) => f,
-            Err(e) => {
-                panic!("Error creating private key file: {}", e);
-            }
-        };
+        let mut f = File::create(p.private_key_path()).context(format!("could not create file {}", p.private_key_path()))?;
         write!(f, "{}", private_key).expect("could not write private key to file");
 
-        p
+
+        Ok(p)
     }
 
     fn private_key_folder(&self) -> String {
@@ -147,4 +143,4 @@ impl PartialEq for Peer {
     fn ne(&self, other: &Self) -> bool {
         return self.ip.ne(&other.ip)
     }
-}
\ No newline at end of file
+}