feat: dump-state --no-net

Author: Kha

src/elan-cli/elan_mode.rs

@@ -58,7 +58,7 @@ pub fn main() -> Result<()> {
                 );
             }
         },
-        ("dump-state", Some(_)) => json_dump::StateDump::new(cfg)?.print()?,
+        ("dump-state", Some(m)) => dump_state(cfg, m)?,
         (_, _) => unreachable!(),
     }
 
@@ -178,7 +178,11 @@ pub fn cli() -> App<'static, 'static> {
             .about("Display which binary will be run for a given command")
             .arg(Arg::with_name("command")
                 .required(true)))
-        .subcommand(SubCommand::with_name("dump-state").setting(AppSettings::Hidden))
+        .subcommand(SubCommand::with_name("dump-state")
+            .setting(AppSettings::Hidden)
+            .arg(Arg::with_name("no-net")
+                .help("Make network operations for resolving channels fail immediately")
+                .long("no-net")))
         /*.subcommand(SubCommand::with_name("doc")
             .alias("docs")
             .about("Open the documentation for the current toolchain")
@@ -551,3 +555,9 @@ fn self_uninstall(m: &ArgMatches) -> Result<()> {
 
     self_update::uninstall(no_prompt)
 }
+
+fn dump_state(cfg: &Cfg, m: &ArgMatches) -> Result<()> {
+    let no_net = m.is_present("no-net");
+
+    Ok(json_dump::StateDump::new(cfg, no_net)?.print()?)
+}

src/elan-cli/json_dump.rs

@@ -1,4 +1,4 @@
-use elan::{lookup_toolchain_desc, utils::{self, fetch_latest_release_tag}, Cfg, Toolchain};
+use elan::{lookup_toolchain_desc_ext, utils::{self, fetch_latest_release_tag}, Cfg, Toolchain};
 use std::{io, path::PathBuf};
 
 use serde_derive::Serialize;
@@ -50,8 +50,8 @@ pub struct StateDump {
 }
 
 impl StateDump {
-    pub fn new(cfg: &Cfg) -> crate::Result<StateDump> {
-        let newest = fetch_latest_release_tag("leanprover/elan", None);
+    pub fn new(cfg: &Cfg, no_net: bool) -> crate::Result<StateDump> {
+        let newest = fetch_latest_release_tag("leanprover/elan", None, no_net);
         let ref cwd = utils::current_dir()?;
         let active_override = cfg.find_override(cwd)?;
         let default = cfg.get_default()?;
@@ -69,15 +69,15 @@ impl StateDump {
                     }).collect(),
                 default: default.as_ref().map(|default| DefaultToolchain {
                     unresolved: default.clone(),
-                    resolved: lookup_toolchain_desc(cfg, &default)
+                    resolved: lookup_toolchain_desc_ext(cfg, &default, no_net)
                       .map(|t| t.to_string())
                       .map_err(|e| e.to_string()),
                 }),
                 active_override: active_override.as_ref().map(|p| p.1.clone()),
                 resolved_active: active_override
                     .map(|p| p.0.desc.to_string())
                     .or(default)
-                    .map(|t| lookup_toolchain_desc(cfg, &t)
+                    .map(|t| lookup_toolchain_desc_ext(cfg, &t, no_net)
                         .map(|tc| tc.to_string())
                         .map_err(|e| e.to_string()))
             },

src/elan-utils/src/utils.rs

@@ -471,11 +471,17 @@ pub fn fetch_url(url: &str) -> Result<String> {
 pub fn fetch_latest_release_tag(
     repo_slug: &str,
     notify_handler: Option<&dyn Fn(Notification)>,
+    no_net: bool
 ) -> Result<String> {
     use regex::Regex;
 
     let latest_url = format!("https://github.com/{}/releases/latest", repo_slug);
-    match fetch_url(&latest_url) {
+    let res = if no_net {
+        Err(Error::from("Cannot fetch latest release tag under `--no-net`"))
+    } else {
+        fetch_url(&latest_url)
+    };
+    match res {
         Ok(redirect) => {
             let re = Regex::new(r#"/tag/([-a-z0-9.]+)"#).unwrap();
             let capture = re.captures(&redirect);

src/elan/install.rs

@@ -26,7 +26,7 @@ pub fn check_self_update() -> Result<Option<String>> {
     // Get current version
     let current_version = env!("CARGO_PKG_VERSION");
 
-    let tag = fetch_latest_release_tag("leanprover/elan", None)?;
+    let tag = fetch_latest_release_tag("leanprover/elan", None, false)?;
     let available_version = &tag[1..];
 
     Ok(if available_version == current_version {

src/elan/toolchain.rs

@@ -36,7 +36,7 @@ pub struct ComponentStatus {
     pub available: bool,
 }
 
-pub fn lookup_toolchain_desc(cfg: &Cfg, name: &str) -> Result<ToolchainDesc> {
+pub fn lookup_toolchain_desc_ext(cfg: &Cfg, name: &str, no_net: bool) -> Result<ToolchainDesc> {
     let pattern = r"^(?:([a-zA-Z0-9-]+[/][a-zA-Z0-9-]+)[:])?([a-zA-Z0-9-.]+)$";
 
     let re = Regex::new(pattern).unwrap();
@@ -64,14 +64,15 @@ pub fn lookup_toolchain_desc(cfg: &Cfg, name: &str) -> Result<ToolchainDesc> {
                 "https://raw.githubusercontent.com/{}/HEAD/lean-toolchain",
                 origin
             );
-            return lookup_toolchain_desc(cfg, fetch_url(&toolchain_url)?.trim());
+            return lookup_toolchain_desc_ext(cfg, fetch_url(&toolchain_url)?.trim(), no_net);
         }
         let mut from_channel = None;
         if release == "stable" || release == "beta" || release == "nightly" {
             from_channel = Some(release);
             release = utils::fetch_latest_release_tag(
                 &origin,
                 Some(&move |n| (cfg.notify_handler)(n.into())),
+                no_net
             )?;
         }
         if release.starts_with(char::is_numeric) {
@@ -83,6 +84,10 @@ pub fn lookup_toolchain_desc(cfg: &Cfg, name: &str) -> Result<ToolchainDesc> {
     }
 }
 
+pub fn lookup_toolchain_desc(cfg: &Cfg, name: &str) -> Result<ToolchainDesc> {
+    lookup_toolchain_desc_ext(cfg, name, false)
+}
+
 impl<'a> Toolchain<'a> {
     pub fn from(cfg: &'a Cfg, desc: &ToolchainDesc) -> Self {
         //We need to replace ":" and "/" with "-" in the toolchain name in order to make a name which is a valid