Use ~/.rustup instead of ~/.multirust

This will silently do the upgrade when rustup is run, and
uses several defenses to avoid breaking due to interactions with rustup.sh.

Author: brson

src/rustup-cli/self_update.rs

@@ -508,7 +508,7 @@ fn cleanup_legacy() -> Result<()> {
 
     #[cfg(unix)]
     fn legacy_multirust_home_dir() -> Result<PathBuf> {
-        Ok(try!(utils::multirust_home()))
+        Ok(try!(utils::legacy_multirust_home()))
     }
 
     #[cfg(windows)]

src/rustup-utils/src/utils.rs

@@ -497,12 +497,141 @@ pub fn cargo_home() -> Result<PathBuf> {
     cargo_home.or(user_home).ok_or(ErrorKind::CargoHome.into())
 }
 
+// Convert the ~/.multirust folder to ~/.rustup while dealing with rustup.sh
+// metadata, which used to also live in ~/.rustup, but now lives in ~/rustup.sh.
+pub fn do_rustup_home_upgrade() -> bool {
+
+    fn rustup_home_is_set() -> bool {
+        env::var_os("RUSTUP_HOME").is_some()
+    }
+
+    fn rustup_dir() -> Option<PathBuf> {
+        dot_dir(".rustup")
+    }
+
+    fn rustup_sh_dir() -> Option<PathBuf> {
+        dot_dir(".rustup.sh")
+    }
+
+    fn multirust_dir() -> Option<PathBuf> {
+        dot_dir(".multirust")
+    }
+
+    fn rustup_dir_exists() -> bool {
+        rustup_dir().map(|p| p.exists()).unwrap_or(false)
+    }
+
+    fn rustup_sh_dir_exists() -> bool {
+        rustup_sh_dir().map(|p| p.exists()).unwrap_or(false)
+    }
+
+    fn multirust_dir_exists() -> bool {
+        multirust_dir().map(|p| p.exists()).unwrap_or(false)
+    }
+
+    fn rustup_old_version_exists() -> bool {
+        rustup_dir()
+            .map(|p| p.join("rustup-version").exists())
+            .unwrap_or(false)
+    }
+
+    fn delete_rustup_dir() -> Result<()> {
+        if let Some(dir) = rustup_dir() {
+            raw::remove_dir(&dir)
+                .chain_err(|| "unable to delete rustup dir")?;
+        }
+
+        Ok(())
+    }
+
+    fn rename_rustup_dir_to_rustup_sh() -> Result<()> {
+        let dirs = (rustup_dir(), rustup_sh_dir());
+        if let (Some(rustup), Some(rustup_sh)) = dirs {
+            fs::rename(&rustup, &rustup_sh)
+                .chain_err(|| "unable to rename rustup dir")?;
+        }
+
+        Ok(())
+    }
+
+    fn rename_multirust_dir_to_rustup() -> Result<()> {
+        let dirs = (multirust_dir(), rustup_dir());
+        if let (Some(rustup), Some(rustup_sh)) = dirs {
+            fs::rename(&rustup, &rustup_sh)
+                .chain_err(|| "unable to rename multirust dir")?;
+        }
+
+        Ok(())
+    }
+
+    // If RUSTUP_HOME is set then its default path doesn't matter, so we're
+    // not going to risk doing any I/O work and making a mess.
+    if rustup_home_is_set() { return true }
+
+    // Now we are just trying to get a bogus, rustup.sh-created ~/.rustup out
+    // of the way in the manner that is least likely to take time and generate
+    // errors. First try to rename it to ~/.rustup.sh, then try to delete it.
+    // If that doesn't work we can't use the ~/.rustup name.
+    let old_rustup_dir_removed = if rustup_old_version_exists() {
+        if !rustup_sh_dir_exists() {
+            if rename_rustup_dir_to_rustup_sh().is_ok() {
+                true
+            } else {
+                if delete_rustup_dir().is_ok() {
+                    true
+                } else {
+                    false
+                }
+            }
+        } else {
+            if delete_rustup_dir().is_ok() {
+                true
+            } else {
+                false
+            }
+        }
+    } else {
+        true
+    };
+
+    // Now we're trying to move ~/.multirust to ~/.rustup
+    old_rustup_dir_removed && if multirust_dir_exists() {
+        if rustup_dir_exists() {
+            // There appears to be both a ~/.multirust dir and a valid ~/.rustup
+            // dir. Weird situation. Pick ~/.rustup.
+            true
+        } else {
+            if rename_multirust_dir_to_rustup().is_ok() {
+                true
+            } else {
+                false
+            }
+        }
+    } else {
+        true
+    }
+}
+
+fn dot_dir(name: &str) -> Option<PathBuf> {
+    home_dir().map(|p| p.join(name))
+}
+
+pub fn legacy_multirust_home() -> Result<PathBuf> {
+    dot_dir(".multirust").ok_or(ErrorKind::MultirustHome.into())
+}
+
 pub fn multirust_home() -> Result<PathBuf> {
+    let use_rustup_dir = do_rustup_home_upgrade();
+
     let cwd = try!(env::current_dir().chain_err(|| ErrorKind::MultirustHome));
     let multirust_home = env::var_os("RUSTUP_HOME").map(|home| {
         cwd.join(home)
     });
-    let user_home = home_dir().map(|p| p.join(".multirust"));
+    let user_home = if use_rustup_dir {
+        dot_dir(".rustup")
+    } else {
+        dot_dir(".multirust")
+    };
     multirust_home.or(user_home).ok_or(ErrorKind::MultirustHome.into())
 }
 

tests/cli-rustup.rs

@@ -5,6 +5,9 @@ extern crate rustup_utils;
 extern crate rustup_mock;
 extern crate tempdir;
 
+use std::fs;
+use std::process;
+use rustup_utils::raw;
 use rustup_mock::clitools::{self, Config, Scenario,
                                expect_ok, expect_ok_ex,
                                expect_stdout_ok,
@@ -544,3 +547,135 @@ fn remove_component() {
         assert!(!path.parent().unwrap().exists());
     });
 }
+
+// Run without setting RUSTUP_HOME, with setting HOME and USERPROFILE
+fn run_no_home(config: &Config, args: &[&str], env: &[(&str, &str)]) -> process::Output {
+    let home_dir_str = &format!("{}", config.homedir.display());
+    let mut cmd = clitools::cmd(config, "rustup", args);
+    clitools::env(config, &mut cmd);
+    cmd.env_remove("RUSTUP_HOME");
+    cmd.env("HOME", home_dir_str);
+    cmd.env("USERPROFILE", home_dir_str);
+    for &(name, val) in env {
+        cmd.env(name, val);
+    }
+    let out = cmd.output().unwrap();
+    assert!(out.status.success());
+
+    out
+}
+
+// Rename ~/.multirust to ~/.rustup
+#[test]
+fn multirust_dir_upgrade_rename_multirust_dir_to_rustup() {
+    setup(&|config| {
+        let multirust_dir = config.homedir.join(".multirust");
+        let rustup_dir = config.homedir.join(".rustup");
+        let multirust_dir_str = &format!("{}", multirust_dir.display());
+
+        // First write data into ~/.multirust
+        run_no_home(config, &["default", "stable"],
+                    &[("RUSTUP_HOME", multirust_dir_str)]);
+        let out = run_no_home(config, &["toolchain", "list"],
+                              &[("RUSTUP_HOME", multirust_dir_str)]);
+        assert!(String::from_utf8(out.stdout).unwrap().contains("stable"));
+
+        assert!(multirust_dir.exists());
+        assert!(!rustup_dir.exists());
+
+        // Next run without RUSTUP_DIR, but with HOME/USERPROFILE set so rustup
+        // can infer RUSTUP_DIR. It will silently move ~/.multirust to
+        // ~/.rustup.
+        let out = run_no_home(config, &["toolchain", "list"], &[]);
+        assert!(String::from_utf8(out.stdout).unwrap().contains("stable"));
+
+        assert!(!multirust_dir.exists());
+        assert!(rustup_dir.exists());
+    });
+}
+
+// Renaming ~/.multirust to ~/.rustup but ~/.rustup/rustup-version (rustup.sh) exists
+#[test]
+fn multirust_dir_upgrade_old_rustup_exists() {
+    setup(&|config| {
+        let multirust_dir = config.homedir.join(".multirust");
+        let rustup_dir = config.homedir.join(".rustup");
+        let rustup_sh_dir = config.homedir.join(".rustup.sh");
+
+        let multirust_dir_str = &format!("{}", multirust_dir.display());
+        let old_rustup_sh_version_file = rustup_dir.join("rustup-version");
+        let new_rustup_sh_version_file = rustup_sh_dir.join("rustup-version");
+
+        // First write data into ~/.multirust
+        run_no_home(config, &["default", "stable"],
+                    &[("RUSTUP_HOME", multirust_dir_str)]);
+        let out = run_no_home(config, &["toolchain", "list"],
+                              &[("RUSTUP_HOME", multirust_dir_str)]);
+        assert!(String::from_utf8(out.stdout).unwrap().contains("stable"));
+
+        assert!(multirust_dir.exists());
+        assert!(!rustup_dir.exists());
+
+        // Now add rustup.sh data to ~/.rustup
+        fs::create_dir_all(&rustup_dir).unwrap();
+        raw::write_file(&old_rustup_sh_version_file, "1").unwrap();
+        assert!(old_rustup_sh_version_file.exists());
+
+        // Now do the upgrade, and ~/.rustup will be moved to ~/.rustup.sh
+        let out = run_no_home(config, &["toolchain", "list"], &[]);
+        assert!(String::from_utf8(out.stdout).unwrap().contains("stable"));
+
+        assert!(!multirust_dir.exists());
+        assert!(rustup_dir.exists());
+        assert!(!old_rustup_sh_version_file.exists());
+        assert!(new_rustup_sh_version_file.exists());
+    });
+}
+
+// Renaming ~/.multirust to ~/.rustup but ~/.rustup/rustup-version (rustup.sh) exists,
+// oh and alse ~/.rustup.sh exists
+#[test]
+fn multirust_dir_upgrade_old_rustup_existsand_new_rustup_sh_exists() {
+    setup(&|config| {
+        let multirust_dir = config.homedir.join(".multirust");
+        let rustup_dir = config.homedir.join(".rustup");
+        let rustup_sh_dir = config.homedir.join(".rustup.sh");
+
+        let multirust_dir_str = &format!("{}", multirust_dir.display());
+        let old_rustup_sh_version_file = rustup_dir.join("rustup-version");
+        let new_rustup_sh_version_file = rustup_sh_dir.join("rustup-version");
+
+        // First write data into ~/.multirust
+        run_no_home(config, &["default", "stable"],
+                    &[("RUSTUP_HOME", multirust_dir_str)]);
+        let out = run_no_home(config, &["toolchain", "list"],
+                              &[("RUSTUP_HOME", multirust_dir_str)]);
+        assert!(String::from_utf8(out.stdout).unwrap().contains("stable"));
+
+        assert!(multirust_dir.exists());
+        assert!(!rustup_dir.exists());
+
+        // This time there are two things that look like rustup.sh.
+        // Only one can win. It doesn't matter much which.
+
+        // Now add rustup.sh data to ~/.rustup
+        fs::create_dir_all(&rustup_dir).unwrap();
+        raw::write_file(&old_rustup_sh_version_file, "1").unwrap();
+
+        // Also to ~/.rustup.sh
+        fs::create_dir_all(&rustup_sh_dir).unwrap();
+        raw::write_file(&new_rustup_sh_version_file, "1").unwrap();
+
+        assert!(old_rustup_sh_version_file.exists());
+        assert!(new_rustup_sh_version_file.exists());
+
+        // Now do the upgrade, and ~/.rustup will be moved to ~/.rustup.sh
+        let out = run_no_home(config, &["toolchain", "list"], &[]);
+        assert!(String::from_utf8(out.stdout).unwrap().contains("stable"));
+
+        assert!(!multirust_dir.exists());
+        assert!(rustup_dir.exists());
+        assert!(!old_rustup_sh_version_file.exists());
+        assert!(new_rustup_sh_version_file.exists());
+    });
+}