chore(cli): fix error handling

src/rust/cli/cmn.rs

@@ -8,6 +8,7 @@ use strsim;
 use std::fs;
 use std::env;
 use std::io;
+use std::error::Error as StdError;
 use std::fmt;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
@@ -401,18 +402,43 @@ impl JsonTokenStorage {
     }
 }
 
+
+#[derive(Debug)]
+pub enum TokenStorageError {
+    Json(json::Error),
+    Io(io::Error),
+}
+
+impl fmt::Display for TokenStorageError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            TokenStorageError::Json(ref err)
+                => writeln!(f, "Could not serialize secrets: {}", err),
+            TokenStorageError::Io(ref err)
+                => writeln!(f, "Failed to write secret token: {}", err),
+        }
+    }
+}
+
+impl StdError for TokenStorageError {
+    fn description(&self) -> &str {
+        "Failure when getting or setting the token storage"
+    }
+}
+
+
 impl TokenStorage for JsonTokenStorage {
-    type Error = json::Error;
+    type Error = TokenStorageError;
 
     // NOTE: logging might be interesting, currently we swallow all errors
-    fn set(&mut self, scope_hash: u64, _: &Vec<&str>, token: Option<Token>) -> Result<(), json::Error> {
+    fn set(&mut self, scope_hash: u64, _: &Vec<&str>, token: Option<Token>) -> Result<(), TokenStorageError> {
         match token {
             None => {
                 match fs::remove_file(self.path(scope_hash)) {
                     Err(err) =>
                         match err.kind() {
                             io::ErrorKind::NotFound => Ok(()),
-                            _ => Err(json::Error::Io(err))
+                            _ => Err(TokenStorageError::Io(err))
                         },
                     Ok(_) => Ok(()),
                 }
@@ -422,27 +448,27 @@ impl TokenStorage for JsonTokenStorage {
                     Ok(mut f) => {
                         match json::to_writer_pretty(&mut f, &token) {
                             Ok(_) => Ok(()),
-                            Err(serde_err) => Err(serde_err),
+                            Err(serde_err) => Err(TokenStorageError::Json(serde_err)),
                         }
                     },
-                    Err(io_err) => Err(json::Error::Io(io_err))
+                    Err(io_err) => Err(TokenStorageError::Io(io_err))
                 }
             }
         }
     }
 
-    fn get(&self, scope_hash: u64, _: &Vec<&str>) -> Result<Option<Token>, json::Error> {
+    fn get(&self, scope_hash: u64, _: &Vec<&str>) -> Result<Option<Token>, TokenStorageError> {
         match fs::File::open(&self.path(scope_hash)) {
             Ok(f) => {
                 match json::de::from_reader(f) {
                     Ok(token) => Ok(Some(token)),
-                    Err(err)  => Err(err),
+                    Err(err)  => Err(TokenStorageError::Json(err)),
                 }
             },
             Err(io_err) => {
                 match io_err.kind() {
                     io::ErrorKind::NotFound => Ok(None),
-                    _ => Err(json::Error::Io(io_err))
+                    _ => Err(TokenStorageError::Io(io_err))
                 }
             }
         }
@@ -680,10 +706,7 @@ pub fn application_secret_from_directory(dir: &str,
                             let console_secret: ConsoleApplicationSecret
                                             = json::from_str(json_console_secret).unwrap();
                             match json::to_writer_pretty(&mut f, &console_secret) {
-                                Err(serde_err) => match serde_err {
-                                    json::Error::Io(err) => err,
-                                    _ => panic!("Unexpected serde error: {:#?}", serde_err)
-                                },
+                                Err(serde_err) => panic!("Unexpected serde error: {:#?}", serde_err),
                                 Ok(_) => continue,
                             }
                         }
@@ -694,8 +717,6 @@ pub fn application_secret_from_directory(dir: &str,
             },
             Ok(f) => {
                 match json::de::from_reader::<_, ConsoleApplicationSecret>(f) {
-                    Err(json::Error::Io(err)) =>
-                        return secret_io_error(err),
                     Err(json_err) =>
                         return Err(CLIError::Configuration(
                             ConfigurationError::Secret(