dist: Support a bincoded manifest file for performance reasons

Cargo.toml

@@ -27,6 +27,7 @@ no-self-update = []
 # Sorted by alphabetic order
 [dependencies]
 anyhow = "1.0.31"
+bincode = "1.3.1"
 cfg-if = "1.0"
 chrono = "0.4"
 clap = "2"

src/dist/dist.rs

@@ -7,6 +7,7 @@ use std::str::FromStr;
 use chrono::{Date, NaiveDate, TimeZone, Utc};
 use lazy_static::lazy_static;
 use regex::Regex;
+use serde::{Deserialize, Serialize};
 
 use crate::dist::download::DownloadCfg;
 use crate::dist::manifest::Manifest as ManifestV2;
@@ -64,7 +65,7 @@ pub struct ToolchainDesc {
     pub target: TargetTriple,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
 pub struct TargetTriple(String);
 
 // Linux hosts don't indicate clib in uname, however binaries only
@@ -417,7 +418,7 @@ impl<'a> Manifest<'a> {
     }
 }
 
-#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub enum Profile {
     Minimal,
     Default,

src/dist/manifest.rs

@@ -20,10 +20,12 @@ use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::str::FromStr;
 
+use serde::{Deserialize, Serialize};
+
 pub const SUPPORTED_MANIFEST_VERSIONS: [&str; 1] = ["2"];
 pub const DEFAULT_MANIFEST_VERSION: &str = "2";
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Manifest {
     pub manifest_version: String,
     pub date: String,
@@ -33,33 +35,33 @@ pub struct Manifest {
     pub profiles: HashMap<Profile, Vec<String>>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Package {
     pub version: String,
     pub targets: PackageTargets,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum PackageTargets {
     Wildcard(TargetedPackage),
     Targeted(HashMap<TargetTriple, TargetedPackage>),
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct TargetedPackage {
     pub bins: Option<PackageBins>,
     pub components: Vec<Component>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct PackageBins {
     pub url: String,
     pub hash: String,
     pub xz_url: Option<String>,
     pub xz_hash: Option<String>,
 }
 
-#[derive(Clone, Debug, Eq, Ord, PartialOrd)]
+#[derive(Clone, Debug, Eq, Ord, PartialOrd, Serialize, Deserialize)]
 pub struct Component {
     pkg: String,
     pub target: Option<TargetTriple>,

src/dist/manifestation.rs

@@ -19,6 +19,7 @@ use crate::errors::*;
 use crate::process;
 use crate::utils::utils;
 
+pub const DIST_MANIFEST_BINCODE: &str = "rustup-channel-manifest.bin";
 pub const DIST_MANIFEST: &str = "multirust-channel-manifest.toml";
 pub const CONFIG_FILE: &str = "multirust-config.toml";
 
@@ -120,7 +121,9 @@ impl Manifestation {
         let temp_cfg = download_cfg.temp_cfg;
         let prefix = self.installation.prefix();
         let rel_installed_manifest_path = prefix.rel_manifest_file(DIST_MANIFEST);
+        let rel_installed_manifest_bin_path = prefix.rel_manifest_file(DIST_MANIFEST_BINCODE);
         let installed_manifest_path = prefix.path().join(&rel_installed_manifest_path);
+        let installed_manifest_bin_path = prefix.path().join(&rel_installed_manifest_bin_path);
 
         // Create the lists of components needed for installation
         let config = self.read_config()?;
@@ -269,6 +272,13 @@ impl Manifestation {
         let new_manifest_str = new_manifest.clone().stringify();
         tx.modify_file(rel_installed_manifest_path)?;
         utils::write_file("manifest", &installed_manifest_path, &new_manifest_str)?;
+        let new_manifest_bytes = bincode::serialize(&new_manifest)?;
+        tx.modify_file(rel_installed_manifest_bin_path)?;
+        utils::write_file_bytes(
+            "manifest",
+            &installed_manifest_bin_path,
+            &new_manifest_bytes,
+        )?;
 
         // Write configuration.
         //
@@ -358,6 +368,11 @@ impl Manifestation {
 
     pub fn load_manifest(&self) -> Result<Option<Manifest>> {
         let prefix = self.installation.prefix();
+        let manifest_bin_path = prefix.manifest_file(DIST_MANIFEST_BINCODE);
+        if utils::path_exists(&manifest_bin_path) {
+            let manifest_bytes = utils::read_file_bytes("installed manifest", &manifest_bin_path)?;
+            return Ok(Some(bincode::deserialize(&manifest_bytes)?));
+        }
         let old_manifest_path = prefix.manifest_file(DIST_MANIFEST);
         if utils::path_exists(&old_manifest_path) {
             let manifest_str = utils::read_file("installed manifest", &old_manifest_path)?;

src/errors.rs

@@ -29,6 +29,7 @@ error_chain! {
         Io(io::Error);
         Open(opener::OpenError);
         Thread(std::sync::mpsc::RecvError);
+        Bincode(bincode::Error);
     }
 
     errors {

src/utils/raw.rs

@@ -52,20 +52,24 @@ pub fn if_not_empty<S: PartialEq<str>>(s: S) -> Option<S> {
     }
 }
 
-pub fn write_file(path: &Path, contents: &str) -> io::Result<()> {
+pub fn write_file_bytes(path: &Path, contents: &[u8]) -> io::Result<()> {
     let mut file = fs::OpenOptions::new()
         .write(true)
         .truncate(true)
         .create(true)
         .open(path)?;
 
-    io::Write::write_all(&mut file, contents.as_bytes())?;
+    io::Write::write_all(&mut file, contents)?;
 
     file.sync_data()?;
 
     Ok(())
 }
 
+pub fn write_file(path: &Path, contents: &str) -> io::Result<()> {
+    write_file_bytes(path, contents.as_bytes())
+}
+
 pub fn filter_file<F: FnMut(&str) -> bool>(
     src: &Path,
     dest: &Path,

src/utils/utils.rs

@@ -61,6 +61,13 @@ pub fn read_file(name: &'static str, path: &Path) -> Result<String> {
     })
 }
 
+pub fn write_file_bytes(name: &'static str, path: &Path, contents: &[u8]) -> Result<()> {
+    raw::write_file_bytes(path, contents).chain_err(|| ErrorKind::WritingFile {
+        name,
+        path: PathBuf::from(path),
+    })
+}
+
 pub fn write_file(name: &'static str, path: &Path, contents: &str) -> Result<()> {
     raw::write_file(path, contents).chain_err(|| ErrorKind::WritingFile {
         name,