Simplify errors

Author: aramperes

rups/src/blocking/mod.rs

@@ -142,7 +142,7 @@ impl TcpConnection {
 
         // Parse args by splitting whitespace, minding quotes for args with multiple words
         let args = shell_words::split(&raw)
-            .map_err(|e| NutError::Generic(format!("Parsing server response failed: {}", e)))?;
+            .map_err(|e| NutError::generic(format!("Parsing server response failed: {}", e)))?;
 
         Ok(args)
     }

rups/src/cmd.rs

@@ -36,11 +36,18 @@ impl fmt::Display for NutError {
                 "Given hostname cannot be used for a strict SSL connection"
             ),
             Self::FeatureNotConfigured => write!(f, "Feature not configured by server"),
-            Self::Generic(msg) => write!(f, "Internal client error: {}", msg),
+            Self::Generic(msg) => write!(f, "Client error: {}", msg),
         }
     }
 }
 
+impl NutError {
+    /// Constructs a generic rups error.
+    pub fn generic<T: ToString>(message: T) -> Self {
+        Self::Generic(message.to_string())
+    }
+}
+
 impl std::error::Error for NutError {}
 
 /// Encapsulation for errors emitted by the client library.
@@ -52,6 +59,13 @@ pub enum ClientError {
     Nut(NutError),
 }
 
+impl ClientError {
+    /// Constructs a generic rups error.
+    pub fn generic<T: ToString>(message: T) -> Self {
+        NutError::generic(message.to_string()).into()
+    }
+}
+
 impl fmt::Display for ClientError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

rups/src/error.rs

@@ -7,6 +7,7 @@
 
 pub use config::*;
 pub use error::*;
+pub use util::*;
 pub use var::*;
 
 /// Blocking client implementation for NUT.
@@ -20,4 +21,5 @@ mod config;
 mod error;
 #[cfg(feature = "ssl")]
 mod ssl;
+mod util;
 mod var;

rups/src/lib.rs

@@ -148,7 +148,7 @@ impl TcpConnection {
 
         // Parse args by splitting whitespace, minding quotes for args with multiple words
         let args = shell_words::split(&raw)
-            .map_err(|e| NutError::Generic(format!("Parsing server response failed: {}", e)))?;
+            .map_err(|e| NutError::generic(format!("Parsing server response failed: {}", e)))?;
 
         Ok(args)
     }

rups/src/tokio/mod.rs

@@ -1,17 +1,21 @@
-use anyhow::Context;
 use std::convert::{TryFrom, TryInto};
 use std::fmt;
 
+/// The default upsd hostname.
 pub const DEFAULT_HOSTNAME: &str = "localhost";
+/// The default upsd port.
 pub const DEFAULT_PORT: u16 = 3493;
 
-/// Connection information for a upsd server.
+/// TCP connection information for a upsd server.
 ///
 /// The upsname is optional depending on context.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct UpsdName<'a> {
+    /// The name of the ups device, if specified.
     pub upsname: Option<&'a str>,
+    /// The hostname of the upsd server.
     pub hostname: &'a str,
+    /// The port of the upsd server.
     pub port: u16,
 }
 
@@ -26,9 +30,9 @@ impl<'a> Default for UpsdName<'a> {
 }
 
 impl<'a> TryFrom<&'a str> for UpsdName<'a> {
-    type Error = anyhow::Error;
+    type Error = crate::ClientError;
 
-    fn try_from(value: &'a str) -> anyhow::Result<UpsdName<'a>> {
+    fn try_from(value: &'a str) -> crate::Result<UpsdName<'a>> {
         let mut upsname: Option<&str> = None;
         let mut hostname = DEFAULT_HOSTNAME;
         let mut port = DEFAULT_PORT;
@@ -40,7 +44,7 @@ impl<'a> TryFrom<&'a str> for UpsdName<'a> {
                 .next()
                 .unwrap()
                 .parse::<u16>()
-                .with_context(|| "invalid port number")?;
+                .map_err(|_| crate::ClientError::generic("Invalid port number"))?;
             if prefix.contains('@') {
                 let mut split = prefix.splitn(2, '@');
                 upsname = Some(split.next().unwrap());
@@ -64,13 +68,13 @@ impl<'a> TryFrom<&'a str> for UpsdName<'a> {
     }
 }
 
-impl<'a> TryInto<rups::Host> for UpsdName<'a> {
-    type Error = anyhow::Error;
+impl<'a> TryInto<crate::Host> for UpsdName<'a> {
+    type Error = crate::ClientError;
 
-    fn try_into(self) -> anyhow::Result<rups::Host> {
+    fn try_into(self) -> crate::Result<crate::Host> {
         (self.hostname.to_owned(), self.port)
             .try_into()
-            .with_context(|| "Invalid hostname/port")
+            .map_err(|_| crate::ClientError::generic("Invalid hostname/port"))
     }
 }
 

rupsc/src/parser.rs rups/src/util.rsrupsc/src/parser.rs renamed to rups/src/util.rs

@@ -200,17 +200,13 @@ impl TryFrom<&str> for VariableType {
                         .nth(1)
                         .map(|s| s.parse().ok())
                         .flatten()
-                        .ok_or_else(|| {
-                            crate::ClientError::Nut(crate::NutError::Generic(
-                                "Invalid STRING definition".into(),
-                            ))
-                        })?;
+                        .ok_or_else(|| crate::ClientError::generic("Invalid STRING definition"))?;
                     Ok(Self::String(size))
                 } else {
-                    Err(crate::ClientError::Nut(crate::NutError::Generic(format!(
+                    Err(crate::ClientError::generic(format!(
                         "Unrecognized variable type: {}",
                         value
-                    ))))
+                    )))
                 }
             }
         }

rups/src/var.rs

@@ -8,9 +8,9 @@ use core::convert::TryInto;
 use anyhow::Context;
 use clap::{App, Arg};
 
-use crate::parser::UpsdName;
+use rups::UpsdName;
+
 mod cmd;
-mod parser;
 
 fn main() -> anyhow::Result<()> {
     let args = App::new(clap::crate_name!())
@@ -72,7 +72,7 @@ fn main() -> anyhow::Result<()> {
         )
         .get_matches();
 
-    let server: parser::UpsdName = args.value_of("upsd-server").map_or_else(
+    let server: UpsdName = args.value_of("upsd-server").map_or_else(
         || Ok(UpsdName::default()),
         |s| s.try_into().with_context(|| "Invalid upsd server name"),
     )?;