Merge pull request #2781 from kinnison/pre-1.8-refetch

Prevent need to refetch for v1 manifests

Author: rbtcollins

src/bin/rustup-init.rs

@@ -95,7 +95,7 @@ fn run_rustup_inner() -> Result<utils::ExitCode> {
         }
         Some(n) => {
             if TOOLS.iter().chain(DUP_TOOLS.iter()).any(|&name| name == n) {
-                proxy_mode::main()
+                proxy_mode::main(n)
             } else {
                 Err(anyhow!(format!(
                     "unknown proxy name: '{}'; valid proxy names are {}",

src/cli/proxy_mode.rs

@@ -1,31 +1,22 @@
 use std::ffi::OsString;
-use std::path::PathBuf;
 use std::process;
 
 use anyhow::Result;
 
 use super::common::set_globals;
-use super::errors::*;
 use super::job;
 use super::self_update;
 use crate::command::run_command_for_dir;
 use crate::utils::utils::{self, ExitCode};
 use crate::Cfg;
 
-pub fn main() -> Result<ExitCode> {
+pub fn main(arg0: &str) -> Result<ExitCode> {
     self_update::cleanup_self_updater()?;
 
     let ExitCode(c) = {
         let _setup = job::setup();
 
-        let mut args = crate::process().args_os();
-
-        let arg0 = args.next().map(PathBuf::from);
-        let arg0 = arg0
-            .as_ref()
-            .and_then(|a| a.file_name())
-            .and_then(std::ffi::OsStr::to_str);
-        let arg0 = arg0.ok_or(CLIError::NoExeName)?;
+        let mut args = crate::process().args_os().skip(1);
 
         // Check for a toolchain specifier.
         let arg1 = args.next();

src/config.rs

@@ -740,8 +740,10 @@ impl Cfg {
             let manifest = if let Some(manifest) = distributable.get_manifest()? {
                 manifest
             } else {
-                // If we can't read the manifest we'd best try and install
-                return Ok(false);
+                // We can't read the manifest.  If this is a v1 install that's understandable
+                // and we assume the components are all good, otherwise we need to have a go
+                // at re-fetching the manifest to try again.
+                return Ok(distributable.guess_v1_manifest());
             };
             match (distributable.list_components(), components_requested) {
                 // If the toolchain does not support components but there were components requested, bubble up the error

src/toolchain.rs

@@ -64,6 +64,8 @@ pub enum UpdateStatus {
     Unchanged,
 }
 
+static V1_COMMON_COMPONENT_LIST: &[&str] = &["cargo", "rustc", "rust-docs"];
+
 impl<'a> Toolchain<'a> {
     pub fn from(cfg: &'a Cfg, name: &str) -> Result<Self> {
         let resolved_name = cfg.resolve_toolchain(name)?;
@@ -953,6 +955,23 @@ impl<'a> DistributableToolchain<'a> {
     fn update_hash(&self) -> Result<PathBuf> {
         self.0.cfg.get_hash_file(&self.0.name, true)
     }
+
+    // Installed only.
+    pub fn guess_v1_manifest(&self) -> bool {
+        let prefix = InstallPrefix::from(self.0.path().to_owned());
+        // If all the v1 common components are present this is likely to be
+        // a v1 manifest install.  The v1 components are not called the same
+        // in a v2 install.
+        for component in V1_COMMON_COMPONENT_LIST {
+            let manifest = format!("manifest-{}", component);
+            let manifest_path = prefix.manifest_file(&manifest);
+            if !utils::path_exists(manifest_path) {
+                return false;
+            }
+        }
+        // It's reasonable to assume this is a v1 manifest installation
+        true
+    }
 }
 
 impl<'a> InstalledToolchain<'a> for DistributableToolchain<'a> {