Convert errors in CLI away from error-chain

3 files changed, 37 insertions, 27 deletions

diff --git a/mullvad-cli/src/cmds/relay.rs b/mullvad-cli/src/cmds/relay.rs
index 33783d309f..7a202e4a5d 100644
--- a/mullvad-cli/src/cmds/relay.rs
+++ b/mullvad-cli/src/cmds/relay.rs
@@ -1,4 +1,4 @@
-use crate::{new_rpc_client, Command, Result, ResultExt};
+use crate::{new_rpc_client, Command, Error, Result};
 use clap::{value_t, values_t};
 use std::{
     io::{self, BufRead},
@@ -335,7 +335,7 @@ impl Relay {
         match vpn_protocol {
             "wireguard" => {
                 if let Constraint::Only(TransportProtocol::Tcp) = protocol {
-                    return Err("WireGuard does not support TCP".into());
+                    return Err(Error::InvalidCommand("WireGuard does not support TCP"));
                 }
                 self.update_constraints(RelaySettingsUpdate::Normal(RelayConstraintsUpdate {
                     location: None,
@@ -393,9 +393,9 @@ impl Relay {
 fn parse_port_constraint(raw_port: &str) -> Result<Constraint<u16>> {
     match raw_port.to_lowercase().as_str() {
         "any" => Ok(Constraint::Any),
-        port => Ok(Constraint::Only(
-            u16::from_str(port).chain_err(|| "Invalid port")?,
-        )),
+        port => Ok(Constraint::Only(u16::from_str(port).map_err(|_| {
+            Error::InvalidCommand("Invalid port. Must be \"any\" or [0-65535].")
+        })?)),
     }
 }
 
diff --git a/mullvad-cli/src/cmds/status.rs b/mullvad-cli/src/cmds/status.rs
index 9310707825..24adfb25f8 100644
--- a/mullvad-cli/src/cmds/status.rs
+++ b/mullvad-cli/src/cmds/status.rs
@@ -1,4 +1,4 @@
-use crate::{new_rpc_client, Command, Error, ErrorKind, Result, ResultExt};
+use crate::{new_rpc_client, Command, Error, Result};
 use futures::{Future, Stream};
 use mullvad_ipc_client::DaemonRpcClient;
 use mullvad_types::{auth_failed::AuthFailed, DaemonEvent};
@@ -36,9 +36,9 @@ impl Command for Status {
             let subscription = rpc
                 .daemon_event_subscribe()
                 .wait()
-                .map_err(|_err| Error::from(ErrorKind::CantSubscribe))?;
+                .map_err(Error::CantSubscribe)?;
             for event in subscription.wait() {
-                match event.chain_err(|| "Subscription failed")? {
+                match event? {
                     DaemonEvent::StateTransition(new_state) => {
                         print_state(&new_state);
                         use self::TunnelStateTransition::*;
diff --git a/mullvad-cli/src/main.rs b/mullvad-cli/src/main.rs
index e4fde0c211..fcb8246cfd 100644
--- a/mullvad-cli/src/main.rs
+++ b/mullvad-cli/src/main.rs
@@ -8,9 +8,6 @@
 
 #![deny(rust_2018_idioms)]
 
-#[macro_use]
-extern crate error_chain;
-
 use clap::{crate_authors, crate_description, crate_name};
 use mullvad_ipc_client::{new_standalone_ipc_client, DaemonRpcClient};
 use std::io;
@@ -20,34 +17,47 @@ mod cmds;
 
 pub const PRODUCT_VERSION: &str = include_str!(concat!(env!("OUT_DIR"), "/product-version.txt"));
 
+pub type Result<T> = std::result::Result<T, Error>;
 
-error_chain! {
+#[derive(err_derive::Error, Debug)]
+pub enum Error {
+    #[error(display = "Failed to connect to daemon")]
+    DaemonNotRunning(#[error(cause)] io::Error),
 
-    errors {
-        DaemonNotRunning(err: io::Error) {
-            description("Failed to connect to daemon")
-            display("Failed to connect to daemon: {}Is the daemon running?", err.display_chain())
-        }
-        CantSubscribe {
-            description("Can't subscribe to daemon states")
-        }
-    }
+    #[error(display = "Can't subscribe to daemon states")]
+    CantSubscribe(#[error(cause)] mullvad_ipc_client::PubSubError),
+
+    #[error(display = "Failed to communicate with mullvad-daemon over RPC")]
+    RpcClientError(#[error(cause)] mullvad_ipc_client::Error),
 
-    foreign_links {
-        Io(io::Error);
-        ParseIntError(::std::num::ParseIntError);
-        RpcClientError(mullvad_ipc_client::Error);
+    /// The given command is not correct in some way
+    #[error(display = "Invalid command: {}", _0)]
+    InvalidCommand(&'static str),
+}
+
+impl From<mullvad_ipc_client::Error> for Error {
+    fn from(e: mullvad_ipc_client::Error) -> Self {
+        Error::RpcClientError(e)
     }
 }
 
 pub fn new_rpc_client() -> Result<DaemonRpcClient> {
     match new_standalone_ipc_client(&mullvad_paths::get_rpc_socket_path()) {
-        Err(e) => Err(ErrorKind::DaemonNotRunning(e).into()),
+        Err(e) => Err(Error::DaemonNotRunning(e)),
         Ok(client) => Ok(client),
     }
 }
 
-quick_main!(run);
+fn main() {
+    let exit_code = match run() {
+        Ok(_) => 0,
+        Err(error) => {
+            eprintln!("{}", error.display_chain());
+            1
+        }
+    };
+    std::process::exit(exit_code);
+}
 
 fn run() -> Result<()> {
     env_logger::init();