Completely overhaul error handling

Cargo.toml

@@ -20,6 +20,7 @@ build = "build.rs"
 [dependencies]
 rustup-dist = { path = "src/rustup-dist" }
 rustup-utils = { path = "src/rustup-utils" }
+rustup-error = { path = "src/rustup-error" }
 clap = "2.2.4"
 regex = "0.1.41"
 openssl = "0.7.2"

src/rustup-cli/common.rs

@@ -1,6 +1,7 @@
 //! Just a dumping ground for cli stuff
 
-use rustup::{Cfg, Result, Notification, Toolchain, Error, UpdateStatus};
+use rustup::{self, Cfg, Notification, Toolchain, UpdateStatus};
+use errors::*;
 use rustup_utils::utils;
 use rustup_utils::notify::NotificationLevel;
 use self_update;
@@ -87,7 +88,8 @@ pub fn read_line() -> Result<String> {
     let stdin = std::io::stdin();
     let stdin = stdin.lock();
     let mut lines = stdin.lines();
-    lines.next().and_then(|l| l.ok()).ok_or(Error::ReadStdin)
+    lines.next().and_then(|l| l.ok()).ok_or(
+        "unable to read from stdin for confirmation".into())
 }
 
 pub fn set_globals(verbose: bool) -> Result<Cfg> {
@@ -96,8 +98,8 @@ pub fn set_globals(verbose: bool) -> Result<Cfg> {
 
     let download_tracker = RefCell::new(DownloadTracker::new());
 
-    Cfg::from_env(shared_ntfy!(move |n: Notification| {
-        if download_tracker.borrow_mut().handle_notification(&n) {
+    Ok(try!(Cfg::from_env(shared_ntfy!(move |n: Notification| { 
+       if download_tracker.borrow_mut().handle_notification(&n) {
             return;
         }
 
@@ -117,16 +119,16 @@ pub fn set_globals(verbose: bool) -> Result<Cfg> {
                 err!("{}", n);
             }
         }
-    }))
+    }))))
 
 }
 
 pub fn show_channel_update(cfg: &Cfg, name: &str,
-                           updated: Result<UpdateStatus>) -> Result<()> {
+                           updated: rustup::Result<UpdateStatus>) -> Result<()> {
     show_channel_updates(cfg, vec![(name.to_string(), updated)])
 }
 
-fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, Result<UpdateStatus>)>) -> Result<()> {
+fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, rustup::Result<UpdateStatus>)>) -> Result<()> {
     let data = toolchains.into_iter().map(|(name, result)| {
         let ref toolchain = cfg.get_toolchain(&name, false).expect("");
         let version = rustc_version(toolchain);
@@ -348,3 +350,35 @@ fn split_override<T: FromStr>(s: &str, separator: char) -> Option<(T, T)> {
         }
     })
 }
+
+pub fn report_error(e: &Error) {
+    err!("{}", e);
+
+    for e in e.iter().skip(1) {
+        info!("caused by: {}", e);
+    }
+
+    if show_backtrace() {
+        info!("backtrace:");
+        println!("");
+        println!("{:?}", e.backtrace());
+    } else {
+    }
+
+    fn show_backtrace() -> bool {
+        use std::env;
+        use std::ops::Deref;
+
+        if env::var("RUST_BACKTRACE").as_ref().map(Deref::deref) == Ok("1") {
+            return true;
+        }
+
+        for arg in env::args() {
+            if arg == "-v" || arg == "--verbose" {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/rustup-cli/errors.rs

@@ -0,0 +1,47 @@
+#![allow(dead_code)]
+
+use std::path::PathBuf;
+
+use rustup;
+use rustup_dist::{self, temp};
+use rustup_utils;
+
+declare_errors! {
+    types {
+        Error, ErrorKind, ChainErr, Result;
+    }
+
+    links {
+        rustup::Error, rustup::ErrorKind, Rustup;
+        rustup_dist::Error, rustup_dist::ErrorKind, Dist;
+        rustup_utils::Error, rustup_utils::ErrorKind, Utils;
+    }
+
+    foreign_links {
+        temp::Error, Temp,
+        "temporary file error";
+    }
+
+    errors {
+        PermissionDenied {
+            description("permission denied")
+        }
+        ToolchainNotInstalled(t: String) {
+            description("toolchain is not installed")
+            display("toolchain '{}' is not installed", t)
+        }
+        InfiniteRecursion {
+            description("infinite recursion detected")
+        }
+        NoExeName {
+            description("couldn't determine self executable name")
+        }
+        NotSelfInstalled(p: PathBuf) {
+            description("rustup is not installed")
+            display("rustup is not installed at '{}'", p.display())
+        }
+        WindowsUninstallMadness {
+            description("failure during windows uninstall")
+        }
+    }
+}

src/rustup-cli/main.rs

@@ -1,6 +1,10 @@
+#![recursion_limit = "1024"]
+
 extern crate rustup_dist;
 #[macro_use]
 extern crate rustup_utils;
+#[macro_use]
+extern crate rustup_error;
 
 #[macro_use]
 extern crate clap;
@@ -39,14 +43,15 @@ mod self_update;
 mod tty;
 mod job;
 mod term2;
+mod errors;
 
 use std::env;
 use std::path::PathBuf;
-use rustup::{Error, Result};
+use errors::*;
 
 fn main() {
-    if let Err(e) = run_multirust() {
-        err!("{}", e);
+    if let Err(ref e) = run_multirust() {
+        common::report_error(e);
         std::process::exit(1);
     }
 }
@@ -56,7 +61,7 @@ fn run_multirust() -> Result<()> {
     let recursion_count = env::var("RUST_RECURSION_COUNT").ok()
         .and_then(|s| s.parse().ok()).unwrap_or(0);
     if recursion_count > 5 {
-        return Err(Error::InfiniteRecursion);
+        return Err(ErrorKind::InfiniteRecursion.into());
     }
 
     // Do various things to clean up past messes
@@ -111,7 +116,7 @@ fn run_multirust() -> Result<()> {
         }
         None => {
             // Weird case. No arg0, or it's unparsable.
-            Err(Error::NoExeName)
+            Err(ErrorKind::NoExeName.into())
         }
     }
 }
@@ -166,3 +171,4 @@ fn fix_windows_reg_key() {
 
 #[cfg(not(windows))]
 fn fix_windows_reg_key() { }
+

src/rustup-cli/multirust_mode.rs

@@ -3,7 +3,8 @@ use cli;
 use common::{self, confirm, set_globals,
              show_channel_update, show_tool_versions,
              update_all_channels};
-use rustup::*;
+use errors::*;
+use rustup::{Cfg, Notification, command, utils, Toolchain};
 use rustup_dist::manifest::Component;
 use rustup_dist::dist::TargetTriple;
 use self_update;
@@ -48,7 +49,7 @@ pub fn main() -> Result<()> {
         ("remove-target", Some(m)) => remove_target(&cfg, m),
         ("run", Some(m)) => run(&cfg, m),
         ("proxy", Some(m)) => proxy(&cfg, m),
-        ("upgrade-data", Some(_)) => cfg.upgrade_data().map(|_| ()),
+        ("upgrade-data", Some(_)) => Ok(try!(cfg.upgrade_data().map(|_| ()))),
         ("delete-data", Some(m)) => delete_data(&cfg, m),
         ("self", Some(c)) => {
             match c.subcommand() {
@@ -79,14 +80,14 @@ fn run(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
     let args = m.values_of("command").unwrap();
     let args: Vec<_> = args.collect();
     let cmd = try!(toolchain.create_command(args[0]));
-    command::run_command_for_dir(cmd, &args, &cfg)
+    Ok(try!(command::run_command_for_dir(cmd, &args, &cfg)))
 }
 
 fn proxy(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
     let args = m.values_of("command").unwrap();
     let args: Vec<_> = args.collect();
     let cmd = try!(cfg.create_command_for_dir(&try!(utils::current_dir()), args[0]));
-    command::run_command_for_dir(cmd, &args, &cfg)
+    Ok(try!(command::run_command_for_dir(cmd, &args, &cfg)))
 }
 
 fn command_requires_metadata() -> Result<bool> {
@@ -120,11 +121,11 @@ fn self_update() -> Result<()> {
 }
 
 fn get_toolchain<'a>(cfg: &'a Cfg, m: &ArgMatches, create_parent: bool) -> Result<Toolchain<'a>> {
-    cfg.get_toolchain(m.value_of("toolchain").unwrap(), create_parent)
+    Ok(try!(cfg.get_toolchain(m.value_of("toolchain").unwrap(), create_parent)))
 }
 
 fn remove_toolchain_args(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
-    try!(get_toolchain(cfg, m, false)).remove()
+    Ok(try!(try!(get_toolchain(cfg, m, false)).remove()))
 }
 
 fn default_(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
@@ -133,7 +134,7 @@ fn default_(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
         if !toolchain.is_custom() {
             Some(try!(toolchain.install_from_dist_if_not_installed()))
         } else if !toolchain.exists() {
-            return Err(Error::ToolchainNotInstalled(toolchain.name().to_string()));
+            return Err(ErrorKind::ToolchainNotInstalled(toolchain.name().to_string()).into());
         } else {
             None
         }
@@ -158,7 +159,7 @@ fn update(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
             if !toolchain.is_custom() {
                 Some(try!(toolchain.install_from_dist()))
             } else if !toolchain.exists() {
-                return Err(Error::ToolchainNotInstalled(toolchain.name().to_string()));
+                return Err(ErrorKind::ToolchainNotInstalled(toolchain.name().to_string()).into());
             } else {
                 None
             }
@@ -224,7 +225,7 @@ fn doc_url(m: &ArgMatches) -> &'static str {
 }
 
 fn doc(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
-    cfg.open_docs_for_dir(&try!(utils::current_dir()), doc_url(m))
+    Ok(try!(cfg.open_docs_for_dir(&try!(utils::current_dir()), doc_url(m))))
 }
 
 fn which(cfg: &Cfg, m: &ArgMatches) -> Result<()> {

src/rustup-cli/proxy_mode.rs

@@ -1,5 +1,6 @@
 use common::set_globals;
-use rustup::{Cfg, Result, Error};
+use rustup::{Cfg};
+use errors::*;
 use rustup_utils::utils;
 use rustup::command::run_command_for_dir;
 use std::env;
@@ -15,7 +16,7 @@ pub fn main() -> Result<()> {
     let arg0 = arg0.as_ref()
         .and_then(|a| a.file_name())
         .and_then(|a| a.to_str());
-    let ref arg0 = try!(arg0.ok_or(Error::NoExeName));
+    let ref arg0 = try!(arg0.ok_or(ErrorKind::NoExeName));
 
     let cfg = try!(set_globals(false));
     try!(cfg.check_metadata_version());
@@ -28,6 +29,6 @@ fn direct_proxy(cfg: &Cfg, arg0: &str) -> Result<()> {
     let cmd = try!(cfg.create_command_for_dir(&try!(utils::current_dir()), arg0));
     let args: Vec<_> = env::args_os().collect();
 
-    run_command_for_dir(cmd, &args, &cfg)
+    Ok(try!(run_command_for_dir(cmd, &args, &cfg)))
 }