Allow rustup to handle unavailable packages

Before this, if a package was unavailable (like nightly is at the moment),
it would error out with a message like "error: missing key: 'url'" because
at the moment a few of the rust-analysis packages didn't build. This resulted
in the `channel-rust-nightly.toml` to be created with blocks like this:

```toml
[pkg.rust-analysis.target.aarch64-apple-ios]
available = false

[pkg.rust-analysis.target.aarch64-linux-android]
available = false

[pkg.rust-analysis.target.aarch64-unknown-fuchsia]
available = false

[pkg.rust-analysis.target.aarch64-unknown-linux-gnu]
available = true
hash = "be50ffa6f94770929b53bae553977cb6d78b03506f033d14a7251c7b0cdb9035"
url = "https://static.rust-lang.org/dist/2017-04-13/rust-analysis-nightly-aarch64-unknown-linux-gnu.tar.gz"
```

rustup assumed that there'd always be a `hash` and `url`, which is not
the case when packages are unavaible. This patch then just updates
rustup to handle their absence.

Author: erickt

src/rustup-dist/src/manifest.rs

@@ -41,13 +41,17 @@ pub enum PackageTargets {
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct TargetedPackage {
-    pub available: bool,
-    pub url: String,
-    pub hash: String,
+    pub url_and_hash: Option<UrlAndHash>,
     pub components: Vec<Component>,
     pub extensions: Vec<Component>,
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub struct UrlAndHash {
+    pub url: String,
+    pub hash: String,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct Component {
     pub pkg: String,
@@ -226,15 +230,25 @@ impl TargetedPackage {
     pub fn from_toml(mut table: toml::Table, path: &str) -> Result<Self> {
         let components = try!(get_array(&mut table, "components", path));
         let extensions = try!(get_array(&mut table, "extensions", path));
-        Ok(TargetedPackage {
-            available: try!(get_bool(&mut table, "available", path)),
-            url: try!(get_string(&mut table, "url", path)),
-            hash: try!(get_string(&mut table, "hash", path)),
-            components: try!(Self::toml_to_components(components,
-                                                      &format!("{}{}.", path, "components"))),
-            extensions: try!(Self::toml_to_components(extensions,
-                                                      &format!("{}{}.", path, "extensions"))),
-        })
+
+        if try!(get_bool(&mut table, "available", path)) {
+            Ok(TargetedPackage {
+                url_and_hash: Some(UrlAndHash {
+                    url: try!(get_string(&mut table, "url", path)),
+                    hash: try!(get_string(&mut table, "hash", path)),
+                }),
+                components: try!(Self::toml_to_components(components,
+                                                          &format!("{}{}.", path, "components"))),
+                extensions: try!(Self::toml_to_components(extensions,
+                                                          &format!("{}{}.", path, "extensions"))),
+            })
+        } else {
+            Ok(TargetedPackage {
+                url_and_hash: None,
+                components: vec![],
+                extensions: vec![],
+            })
+        }
     }
     pub fn to_toml(self) -> toml::Table {
         let extensions = Self::components_to_toml(self.extensions);
@@ -246,12 +260,20 @@ impl TargetedPackage {
         if !components.is_empty() {
             result.insert("components".to_owned(), toml::Value::Array(components));
         }
-        result.insert("hash".to_owned(), toml::Value::String(self.hash));
-        result.insert("url".to_owned(), toml::Value::String(self.url));
-        result.insert("available".to_owned(), toml::Value::Boolean(self.available));
+        if let Some(UrlAndHash { url, hash }) = self.url_and_hash {
+            result.insert("hash".to_owned(), toml::Value::String(hash));
+            result.insert("url".to_owned(), toml::Value::String(url));
+            result.insert("available".to_owned(), toml::Value::Boolean(true));
+        } else {
+            result.insert("available".to_owned(), toml::Value::Boolean(false));
+        }
         result
     }
 
+    pub fn available(&self) -> bool {
+        self.url_and_hash.is_some()
+    }
+
     fn toml_to_components(arr: toml::Array, path: &str) -> Result<Vec<Component>> {
         let mut result = Vec::new();
 

src/rustup-dist/src/manifestation.rs

@@ -2,7 +2,7 @@
 //! platform components from a distribution server.
 
 use config::Config;
-use manifest::{Component, Manifest, TargetedPackage};
+use manifest::{Component, Manifest, TargetedPackage, UrlAndHash};
 use dist::{download_and_check, DownloadCfg, TargetTriple, DEFAULT_DIST_SERVER, File};
 use component::{Components, Transaction, TarGzPackage, Package};
 use temp;
@@ -106,7 +106,7 @@ impl Manifestation {
             use manifest::*;
             let pkg: Option<&Package> = new_manifest.get_package(&c.pkg).ok();
             let target_pkg: Option<&TargetedPackage> = pkg.and_then(|p| p.get_target(c.target.as_ref()).ok());
-            target_pkg.map(|tp| tp.available) != Some(true)
+            target_pkg.map(|tp| tp.available()) != Some(true)
         }).cloned().collect();
 
         if !unavailable_components.is_empty() {
@@ -118,8 +118,11 @@ impl Manifestation {
         for component in components_to_install {
             let package = try!(new_manifest.get_package(&component.pkg));
             let target_package = try!(package.get_target(component.target.as_ref()));
-            let c_u_h = (component, target_package.url.clone(), target_package.hash.clone());
-            components_urls_and_hashes.push(c_u_h);
+
+            if let Some(UrlAndHash { ref url, ref hash }) = target_package.url_and_hash {
+                let c_u_h = (component, url.clone(), hash.clone());
+                components_urls_and_hashes.push(c_u_h);
+            }
         }
 
         let altered = temp_cfg.dist_server != DEFAULT_DIST_SERVER;

src/rustup/toolchain.rs

@@ -474,7 +474,7 @@ impl<'a> Toolchain<'a> {
                     component: component.clone(),
                     required: true,
                     installed: installed,
-                    available: component_target_pkg.available,
+                    available: component_target_pkg.available(),
                 });
             }
 
@@ -493,7 +493,7 @@ impl<'a> Toolchain<'a> {
                     component: extension.clone(),
                     required: false,
                     installed: installed,
-                    available: extension_target_pkg.available,
+                    available: extension_target_pkg.available(),
                 });
             }
 

tests/cli-v2.rs

@@ -667,7 +667,7 @@ fn make_component_unavailable(config: &Config, name: &str, target: &TargetTriple
     {
         let mut std_pkg = manifest.packages.get_mut(name).unwrap();
         let mut target_pkg = std_pkg.targets.get_mut(target).unwrap();
-        target_pkg.available = false;
+        target_pkg.url_and_hash = None;
     }
     let ref manifest_str = manifest.stringify();
     rustup_utils::raw::write_file(manifest_path, manifest_str).unwrap();