Restructure error handling

Author: qzed

Cargo.lock

@@ -11,15 +11,6 @@ license = "MIT"
 edition = "2018"
 build = "build.rs"
 
-[dependencies]
-clap = "2.33.0"
-indoc = "0.3.1"
-nix = "0.13.0"
-
-[build-dependencies]
-clap = "2.33.0"
-indoc = "0.3.1"
-
 [package.metadata.deb]
 maintainer = "Maximilian Luz <[email protected]>"
 license-file = ["LICENSE", "0"]
@@ -35,3 +26,13 @@ assets = [
     ["target/_surface", "usr/share/zsh/vendor-completions/_surface", "644"],
     ["target/surface.fish", "usr/share/fish/completions/surface.fish", "644"],
 ]
+
+[dependencies]
+clap = "2.33.0"
+indoc = "0.3.1"
+nix = "0.13.0"
+failure = "0.1.5"
+
+[build-dependencies]
+clap = "2.33.0"
+indoc = "0.3.1"

Cargo.toml

@@ -0,0 +1,61 @@
+use failure::{Context, Fail, Backtrace};
+
+
+pub type Result<T> = std::result::Result<T, Error>;
+pub use failure::ResultExt;
+
+#[derive(Debug)]
+pub struct Error {
+    inner: Context<ErrorKind>
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Fail)]
+pub enum ErrorKind {
+    #[fail(display = "I/O failure")]
+    Io,
+
+    #[fail(display = "Received invalid data")]
+    InvalidData,
+
+    #[fail(display = "Cannot access device")]
+    DeviceAccess,
+}
+
+
+impl Error {
+    pub fn kind(&self) -> ErrorKind {
+        *self.inner.get_context()
+    }
+
+    pub fn iter_causes(&self) -> failure::Causes {
+        ((&self.inner) as &dyn Fail).iter_causes()
+    }
+}
+
+impl From<ErrorKind> for Error {
+    fn from(kind: ErrorKind) -> Error {
+        Error { inner: Context::new(kind) }
+    }
+}
+
+impl From<Context<ErrorKind>> for Error {
+    fn from(inner: Context<ErrorKind>) -> Error {
+        Error { inner: inner }
+    }
+}
+
+impl Fail for Error {
+    fn cause(&self) -> Option<&Fail> {
+        self.inner.cause()
+    }
+
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.inner.backtrace()
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.inner, f)
+    }
+}

src/error.rs

@@ -1,8 +1,9 @@
-use std::io::Result;
-
+mod error;
 mod cli;
 mod sys;
 
+use crate::error::Result;
+
 
 fn main() {
     let matches = cli::app().get_matches();
@@ -16,7 +17,11 @@ fn main() {
     };
 
     if let Err(e) = result {
-        eprintln!("Error: {}", e);
+        eprintln!("Error: {}.", e.kind());
+
+        for cause in e.iter_causes() {
+            eprintln!("       {}.", cause);
+        }
     }
 }
 

src/main.rs

@@ -1,6 +1,8 @@
 use std::fs::OpenOptions;
 use std::path::{Path, PathBuf};
-use std::io::{Result, Error, ErrorKind, Read, Write};
+use std::io::{Read, Write};
+
+use crate::error::{Error, ErrorKind, Result, ResultExt};
 
 
 #[derive(Debug, Copy, Clone)]
@@ -32,12 +34,15 @@ impl std::fmt::Display for PowerState {
     }
 }
 
+
+#[derive(Debug)]
+pub struct InvalidPowerStateError;
+
 impl std::str::FromStr for PowerState {
-    type Err = String;
+    type Err = InvalidPowerStateError;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        PowerState::from_str(s)
-            .ok_or(format!("invalid power state: '{}'", s))
+        PowerState::from_str(s).ok_or(InvalidPowerStateError)
     }
 }
 
@@ -55,7 +60,9 @@ impl Device {
         if path.as_ref().is_dir() {
             Ok(Device { path: path.as_ref().to_owned() })
         } else {
-            Err(Error::new(ErrorKind::NotFound, "No Surface dGPU device found"))
+            Err(failure::err_msg("Surface dGPU hot-plug device not found"))
+                .context(ErrorKind::DeviceAccess)
+                .map_err(|e| e.into())
         }
     }
 
@@ -64,34 +71,35 @@ impl Device {
 
         let mut file = OpenOptions::new()
             .read(true)
-            .open(self.path.as_path().join("dgpu_power"))?;
+            .open(self.path.as_path().join("dgpu_power"))
+            .context(ErrorKind::DeviceAccess)?;
 
         let mut buf = [0; 4];
-        let len = file.read(&mut buf)?;
+        let len = file.read(&mut buf).context(ErrorKind::Io)?;
 
         let state = CStr::from_bytes_with_nul(&buf[0..len+1])
-            .map_err(|_| Error::new(ErrorKind::InvalidData, "Device returned invalid data"))?
-            .to_str()
-            .map_err(|_| Error::new(ErrorKind::InvalidData, "Device returned invalid data"))?
+            .context(ErrorKind::InvalidData)?
+            .to_str().context(ErrorKind::InvalidData)?
             .trim();
 
         PowerState::from_str(state)
-            .ok_or_else(|| Error::new(ErrorKind::InvalidData, "Device returned invalid data"))
+            .ok_or_else(|| Error::from(ErrorKind::InvalidData))
     }
 
     pub fn set_power(&self, state: PowerState) -> Result<()> {
         let state = state.as_str().as_bytes();
 
         let mut file = OpenOptions::new()
             .write(true)
-            .open(self.path.as_path().join("dgpu_power"))?;
+            .open(self.path.as_path().join("dgpu_power"))
+            .context(ErrorKind::DeviceAccess)?;
 
-        let len = file.write(state)?;
+        let len = file.write(state).context(ErrorKind::Io)?;
 
         if len == state.len() {
             Ok(())
         } else {
-            Err(Error::new(ErrorKind::Other, "Failed to write to device"))
+            Err(Error::from(ErrorKind::Io))
         }
     }
 }