Auto merge of #1100 - ranma42:package-xz, r=Diggsey

Add support for XZ-compressed packages

When XZ-compressed packages are available, prefer them in place of the
GZip-compressed ones as they can provide significant savings interms
of download size.

This should be the last step towards fixing rust-lang/rust#21724

Author: bors

Cargo.lock

@@ -19,6 +19,7 @@ ole32-sys = "0.2.0"
 url = "1.1.0"
 tar = "0.4.0"
 flate2 = "0.2.9"
+xz2 = "0.1.3"
 tempdir = "0.3.4"
 walkdir = "0.1.5"
 toml = "0.1.27"

src/rustup-dist/Cargo.toml

@@ -4,6 +4,7 @@
 
 extern crate tar;
 extern crate flate2;
+extern crate xz2;
 
 use component::components::*;
 use component::transaction::*;
@@ -261,3 +262,35 @@ impl<'a> Package for TarGzPackage<'a> {
         self.0.components()
     }
 }
+
+#[derive(Debug)]
+pub struct TarXzPackage<'a>(TarPackage<'a>);
+
+impl<'a> TarXzPackage<'a> {
+    pub fn new<R: Read>(stream: R, temp_cfg: &'a temp::Cfg) -> Result<Self> {
+        let stream = xz2::read::XzDecoder::new(stream);
+
+        Ok(TarXzPackage(try!(TarPackage::new(stream, temp_cfg))))
+    }
+    pub fn new_file(path: &Path, temp_cfg: &'a temp::Cfg) -> Result<Self> {
+        let file = try!(File::open(path).chain_err(|| ErrorKind::ExtractingPackage));
+        Self::new(file, temp_cfg)
+    }
+}
+
+impl<'a> Package for TarXzPackage<'a> {
+    fn contains(&self, component: &str, short_name: Option<&str>) -> bool {
+        self.0.contains(component, short_name)
+    }
+    fn install<'b>(&self,
+                   target: &Components,
+                   component: &str,
+                   short_name: Option<&str>,
+                   tx: Transaction<'b>)
+                   -> Result<Transaction<'b>> {
+        self.0.install(target, component, short_name, tx)
+    }
+    fn components(&self) -> Vec<String> {
+        self.0.components()
+    }
+}

src/rustup-dist/src/component/package.rs

@@ -44,6 +44,8 @@ pub struct TargetedPackage {
     pub available: bool,
     pub url: String,
     pub hash: String,
+    pub xz_url: Option<String>,
+    pub xz_hash: Option<String>,
     pub components: Vec<Component>,
     pub extensions: Vec<Component>,
 }
@@ -230,6 +232,8 @@ impl 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)),
+            xz_url: get_string(&mut table, "xz_url", path).ok(),
+            xz_hash: get_string(&mut table, "xz_hash", path).ok(),
             components: try!(Self::toml_to_components(components,
                                                       &format!("{}{}.", path, "components"))),
             extensions: try!(Self::toml_to_components(extensions,

src/rustup-dist/src/manifest.rs

@@ -4,7 +4,7 @@
 use config::Config;
 use manifest::{Component, Manifest, TargetedPackage};
 use dist::{TargetTriple, DEFAULT_DIST_SERVER};
-use component::{Components, Transaction, TarGzPackage, Package};
+use component::{Components, Transaction, TarGzPackage, TarXzPackage, Package};
 use temp;
 use errors::*;
 use notifications::*;
@@ -16,6 +16,11 @@ use std::path::Path;
 pub const DIST_MANIFEST: &'static str = "multirust-channel-manifest.toml";
 pub const CONFIG_FILE: &'static str = "multirust-config.toml";
 
+enum Format {
+    Gz,
+    Xz,
+}
+
 #[derive(Debug)]
 pub struct Manifestation {
     installation: Components,
@@ -115,20 +120,26 @@ impl Manifestation {
         }
 
         // Map components to urls and hashes
-        let mut components_urls_and_hashes: Vec<(Component, String, String)> = Vec::new();
+        let mut components_urls_and_hashes: Vec<(Component, Format, String, String)> = Vec::new();
         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());
+            let c_u_h =
+                if let (Some(url), Some(hash)) = (target_package.xz_url.clone(),
+                                                 target_package.xz_hash.clone()) {
+                    (component, Format::Xz, url, hash)
+                } else {
+                    (component, Format::Gz, target_package.url.clone(), target_package.hash.clone())
+                };
             components_urls_and_hashes.push(c_u_h);
         }
 
         let altered = temp_cfg.dist_server != DEFAULT_DIST_SERVER;
 
         // Download component packages and validate hashes
-        let mut things_to_install: Vec<(Component, File)> = Vec::new();
+        let mut things_to_install: Vec<(Component, Format, File)> = Vec::new();
         let mut things_downloaded: Vec<String> = Vec::new();
-        for (component, url, hash) in components_urls_and_hashes {
+        for (component, format, url, hash) in components_urls_and_hashes {
 
             notify_handler(Notification::DownloadingComponent(&component.pkg,
                                                               &self.target_triple,
@@ -146,7 +157,7 @@ impl Manifestation {
             }));
             things_downloaded.push(hash);
 
-            things_to_install.push((component, dowloaded_file));
+            things_to_install.push((component, format, dowloaded_file));
         }
 
         // Begin transaction
@@ -167,13 +178,24 @@ impl Manifestation {
         }
 
         // Install components
-        for (component, installer_file) in things_to_install {
+        for (component, format, installer_file) in things_to_install {
 
             notify_handler(Notification::InstallingComponent(&component.pkg,
                                                              &self.target_triple,
                                                              component.target.as_ref()));
 
-            let package = try!(TarGzPackage::new_file(&installer_file, temp_cfg));
+            let gz;
+            let xz;
+            let package: &Package = match format {
+                Format::Gz => {
+                    gz = try!(TarGzPackage::new_file(&installer_file, temp_cfg));
+                    &gz
+                }
+                Format::Xz => {
+                    xz = try!(TarXzPackage::new_file(&installer_file, temp_cfg));
+                    &xz
+                }
+            };
 
             // For historical reasons, the rust-installer component
             // names are not the same as the dist manifest component