Adding rustup check command to see if there are updates on the installed channels

Author: chunk0tronic

src/cli/rustup_mode.rs

@@ -49,6 +49,7 @@ pub fn main() -> Result<()> {
         },
         ("install", Some(m)) => update(cfg, m)?,
         ("update", Some(m)) => update(cfg, m)?,
+        ("check", Some(_)) => check_updates(cfg)?,
         ("uninstall", Some(m)) => toolchain_remove(cfg, m)?,
         ("default", Some(m)) => default_(cfg, m)?,
         ("toolchain", Some(c)) => match c.subcommand() {
@@ -200,6 +201,10 @@ pub fn cli() -> App<'static, 'static> {
                         .takes_value(false),
                 ),
         )
+        .subcommand(
+            SubCommand::with_name("check")
+                .about("Check for updates to Rust toolchains")
+        )
         .subcommand(
             SubCommand::with_name("default")
                 .about("Set the default toolchain")
@@ -668,6 +673,48 @@ fn default_(cfg: &Cfg, m: &ArgMatches<'_>) -> Result<()> {
     Ok(())
 }
 
+fn check_updates(cfg: &Cfg) -> Result<()> {
+    let mut t = term2::stdout();
+    let channels = cfg.list_channels()?;
+
+    for channel in channels {
+        match channel {
+            (ref name, Ok(ref toolchain)) => {
+                let current_version = toolchain.show_version()?;
+                let dist_version = toolchain.show_dist_version()?;
+                let _ = t.attr(term2::Attr::Bold);
+                write!(t, "{} - ", name)?;
+                match (current_version, dist_version) {
+                    (None, None) => {
+                        let _ = t.fg(term2::color::BRIGHT_RED);
+                        writeln!(t, "Cannot identify installed or update versions")?;
+                    }
+                    (Some(cv), None) => {
+                        let _ = t.fg(term2::color::BRIGHT_GREEN);
+                        write!(t, "Up to date")?;
+                        let _ = t.reset();
+                        writeln!(t, " : {}", cv)?;
+                    }
+                    (Some(cv), Some(dv)) => {
+                        let _ = t.fg(term2::color::BRIGHT_YELLOW);
+                        write!(t, "Update available")?;
+                        let _ = t.reset();
+                        writeln!(t, " : {} -> {}", cv, dv)?;
+                    }
+                    (None, Some(dv)) => {
+                        let _ = t.fg(term2::color::BRIGHT_YELLOW);
+                        write!(t, "Update available")?;
+                        let _ = t.reset();
+                        writeln!(t, " : (Unknown version) -> {}", dv)?;
+                    }
+                }
+            }
+            (_, Err(err)) => return Err(err.into()),
+        }
+    }
+    Ok(())
+}
+
 fn update(cfg: &Cfg, m: &ArgMatches<'_>) -> Result<()> {
     let self_update = !m.is_present("no-self-update") && !self_update::NEVER_SELF_UPDATE;
     if let Some(names) = m.values_of("toolchain") {

src/config.rs

@@ -390,22 +390,28 @@ impl Cfg {
         }
     }
 
-    pub fn update_all_channels(
-        &self,
-        force_update: bool,
-    ) -> Result<Vec<(String, Result<UpdateStatus>)>> {
+    pub fn list_channels(&self) -> Result<Vec<(String, Result<Toolchain<'_>>)>> {
         let toolchains = self.list_toolchains()?;
 
         // Convert the toolchain strings to Toolchain values
         let toolchains = toolchains.into_iter();
         let toolchains = toolchains.map(|n| (n.clone(), self.get_toolchain(&n, true)));
 
         // Filter out toolchains that don't track a release channel
-        let toolchains = toolchains
-            .filter(|&(_, ref t)| t.as_ref().map(Toolchain::is_tracking).unwrap_or(false));
+        Ok(toolchains
+            .filter(|&(_, ref t)| t.as_ref().map(Toolchain::is_tracking).unwrap_or(false))
+            .collect())
+    }
+
+    pub fn update_all_channels(
+        &self,
+        force_update: bool,
+    ) -> Result<Vec<(String, Result<UpdateStatus>)>> {
+        let channels = self.list_channels()?;
+        let channels = channels.into_iter();
 
         // Update toolchains and collect the results
-        let toolchains = toolchains.map(|(n, t)| {
+        let channels = channels.map(|(n, t)| {
             let t = t.and_then(|t| {
                 let t = t.install_from_dist(force_update);
                 if let Err(ref e) = t {
@@ -417,7 +423,7 @@ impl Cfg {
             (n, t)
         });
 
-        Ok(toolchains.collect())
+        Ok(channels.collect())
     }
 
     pub fn check_metadata_version(&self) -> Result<()> {

src/dist/dist.rs

@@ -679,7 +679,7 @@ fn update_from_dist_<'a>(
     }
 }
 
-fn dl_v2_manifest<'a>(
+pub fn dl_v2_manifest<'a>(
     download: DownloadCfg<'a>,
     update_hash: Option<&Path>,
     toolchain: &ToolchainDesc,

src/toolchain.rs

@@ -470,6 +470,36 @@ impl<'a> Toolchain<'a> {
         })
     }
 
+    pub fn show_version(&self) -> Result<Option<String>> {
+        if !self.exists() {
+            return Err(ErrorKind::ToolchainNotInstalled(self.name.to_owned()).into());
+        }
+
+        let toolchain = &self.name;
+        let toolchain = ToolchainDesc::from_str(toolchain)?;
+
+        let prefix = InstallPrefix::from(self.path.to_owned());
+        let manifestation = Manifestation::open(prefix, toolchain.target.clone())?;
+
+        match manifestation.load_manifest()? {
+            Some(manifest) => Ok(Some(manifest.get_rust_version()?.to_string())),
+            None => Ok(None),
+        }
+    }
+
+    pub fn show_dist_version(&self) -> Result<Option<String>> {
+        let update_hash = self.update_hash()?;
+
+        match crate::dist::dist::dl_v2_manifest(
+            self.download_cfg(),
+            update_hash.as_ref().map(|p| &**p),
+            &self.desc()?,
+        )? {
+            Some((manifest, _)) => Ok(Some(manifest.get_rust_version()?.to_string())),
+            None => Ok(None),
+        }
+    }
+
     pub fn list_components(&self) -> Result<Vec<ComponentStatus>> {
         if !self.exists() {
             return Err(ErrorKind::ToolchainNotInstalled(self.name.to_owned()).into());