Only compile executables once per process

alexcrichton · alexcrichton · commit 560fcb6c806d · 2017-08-11T09:32:12.000-07:00
Use auxiliary files to store version information instead of embedding it
directly in the executable.
diff --git a/src/rustup-mock/src/clitools.rs b/src/rustup-mock/src/clitools.rs
@@ -2,15 +2,14 @@
 //! tests/cli-v2.rs
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::env::consts::EXE_SUFFIX;
 use std::env;
 use std::fs::{self, File};
 use std::io::{self, Read, Write};
 use std::mem;
 use std::path::{PathBuf, Path};
 use std::process::{Command, Stdio};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::time::Duration;
 use tempdir::TempDir;
 use {MockInstallerBuilder, MockFile, MockComponentBuilder};
@@ -565,10 +564,7 @@ fn build_mock_rustc_installer(target: &str, version: &str, version_hash_: &str)
     MockInstallerBuilder {
         components: vec![MockComponentBuilder {
             name: "rustc".to_string(),
-            files: vec![
-                MockFile::new_arc(format!("bin/rustc{}", EXE_SUFFIX),
-                                  mock_bin("rustc", version, &version_hash)),
-            ],
+            files: mock_bin("rustc", version, &version_hash),
         }],
     }
 }
@@ -577,10 +573,7 @@ fn build_mock_cargo_installer(version: &str, version_hash: &str) -> MockInstalle
     MockInstallerBuilder {
         components: vec![MockComponentBuilder {
             name: "cargo".to_string(),
-            files: vec![
-                MockFile::new_arc(format!("bin/cargo{}", EXE_SUFFIX),
-                                  mock_bin("cargo", version, &version_hash)),
-            ],
+            files: mock_bin("cargo", version, &version_hash),
         }],
     }
 }
@@ -589,10 +582,7 @@ fn build_mock_rls_installer(version: &str, version_hash: &str) -> MockInstallerB
     MockInstallerBuilder {
         components: vec![MockComponentBuilder {
             name: "rls".to_string(),
-            files: vec![
-                MockFile::new_arc(format!("bin/rls{}", EXE_SUFFIX),
-                                  mock_bin("rls", version, &version_hash)),
-            ],
+            files: mock_bin("rls", version, version_hash),
         }],
     }
 }
@@ -640,112 +630,68 @@ fn build_combined_installer(components: &[&MockInstallerBuilder]) -> MockInstall
 /// prints some version information. These binaries are stuffed into
 /// the mock installers so we have executables for rustup to run.
 ///
-/// This does a really crazy thing. Because we need to generate a lot
-/// of these, and running rustc is slow, it does it once, stuffs the
-/// bin into memory, then does a string replacement of the version
-/// information it needs to report to create subsequent bins.
-fn mock_bin(_name: &str, version: &str, version_hash: &str) -> Arc<Vec<u8>> {
+/// To avoid compiling tons of files we globally cache one compiled executable
+/// and then we store some associated files next to it which indicate
+/// the version/version hash information.
+fn mock_bin(name: &str, version: &str, version_hash: &str) -> Vec<MockFile> {
     lazy_static! {
-        static ref MOCK_BIN_TEMPLATE: Mutex<HashMap<(String, String), Arc<Vec<u8>>>> =
-            Mutex::new(HashMap::new());
-    }
-
-    let key = (version.to_string(), version_hash.to_string());
-    let map = MOCK_BIN_TEMPLATE.lock().unwrap();
-    if let Some(ret) = map.get(&key) {
-        return ret.clone()
-    }
-    drop(map);
-
-    struct Stderr;
-    use std::fmt::{self, Write};
-
-    impl fmt::Write for Stderr {
-        fn write_str(&mut self, s: &str) -> fmt::Result {
-            unsafe {
-                extern {
-                    fn write(a: i32, b: *const u8, c: usize) -> isize;
-                }
-                write(2, s.as_ptr(), s.len());
-                Ok(())
+        static ref MOCK_BIN: Arc<Vec<u8>> = {
+            // Create a temp directory to hold the source and the output
+            let ref tempdir = TempDir::new("rustup").unwrap();
+            let ref source_path = tempdir.path().join("in.rs");
+            let ref dest_path = tempdir.path().join(&format!("out{}", EXE_SUFFIX));
+
+            // Write the source
+            let source = include_str!("mock_bin_src.rs");
+            File::create(source_path).and_then(|mut f| f.write_all(source.as_bytes())).unwrap();
+
+            // Create the executable
+            let status = Command::new("rustc")
+                .arg(&source_path)
+                .arg("-C").arg("panic=abort")
+                .arg("-O")
+                .arg("-o").arg(&dest_path)
+                .status()
+                .unwrap();
+            assert!(status.success());
+            assert!(dest_path.exists());
+
+            // If we're on unix this will remove debuginfo, otherwise we just ignore
+            // the return result here
+            if cfg!(unix) {
+                drop(Command::new("strip").arg(&dest_path).status());
             }
-        }
-    }
-    drop(write!(Stderr, "cache miss {:?}\n", key));
-
-    // Create a temp directory to hold the source and the output
-    let ref tempdir = TempDir::new("rustup").unwrap();
-    let ref source_path = tempdir.path().join("in.rs");
-    let ref dest_path = tempdir.path().join(&format!("out{}", EXE_SUFFIX));
-
-    // Write the source
-    let source = include_str!("mock_bin_src.rs");
-    File::create(source_path).and_then(|mut f| f.write_all(source.as_bytes())).unwrap();
 
-    // Create the executable
-    let status = Command::new("rustc")
-        .arg(&source_path)
-        .arg("-C").arg("panic=abort")
-        .arg("-O")
-        .arg("-o").arg(&dest_path)
-        .env("EXAMPLE_VERSION", version)
-        .env("EXAMPLE_VERSION_HASH", version_hash)
-        .status()
-        .unwrap();
-    assert!(status.success());
-    assert!(dest_path.exists());
+            // Now load it into memory
+            let mut f = File::open(dest_path).unwrap();
+            let mut buf = Vec::new();
+            f.read_to_end(&mut buf).unwrap();
 
-    // If we're on unix this will remove debuginfo, otherwise we just ignore
-    // the return result here
-    if cfg!(unix) {
-        drop(Command::new("strip").arg(&dest_path).status());
+            Arc::new(buf)
+        };
     }
 
-    // Now load it into memory
-    let mut f = File::open(dest_path).unwrap();
-    let mut buf = Vec::new();
-    f.read_to_end(&mut buf).unwrap();
-
-    let buf = Arc::new(buf);
-    MOCK_BIN_TEMPLATE.lock().unwrap().insert(key, buf.clone());
-    return buf
+    let name = format!("bin/{}{}", name, EXE_SUFFIX);
+    vec![
+        MockFile::new(format!("{}.version", name), version.as_bytes()),
+        MockFile::new(format!("{}.version-hash", name), version_hash.as_bytes()),
+        MockFile::new_arc(name, MOCK_BIN.clone()).executable(true),
+    ]
 }
 
 // These are toolchains for installation with --link-local and --copy-local
 fn create_custom_toolchains(customdir: &Path) {
-    let ref dir = customdir.join("custom-1/bin");
-    fs::create_dir_all(dir).unwrap();
     let ref libdir = customdir.join("custom-1/lib");
     fs::create_dir_all(libdir).unwrap();
-    let rustc = mock_bin("rustc", "1.0.0", "hash-c-1");
-    let ref path = customdir.join(format!("custom-1/bin/rustc{}", EXE_SUFFIX));
-    let mut file = File::create(path).unwrap();
-    file.write_all(&rustc).unwrap();
-    make_exe(dir, path);
-
-    let ref dir = customdir.join("custom-2/bin");
-    fs::create_dir_all(dir).unwrap();
+    for file in mock_bin("rustc", "1.0.0", "hash-c-1") {
+        file.build(&customdir.join("custom-1"));
+    }
+
     let ref libdir = customdir.join("custom-2/lib");
     fs::create_dir_all(libdir).unwrap();
-    let rustc = mock_bin("rustc", "1.0.0", "hash-c-2");
-    let ref path = customdir.join(format!("custom-2/bin/rustc{}", EXE_SUFFIX));
-    let mut file = File::create(path).unwrap();
-    file.write_all(&rustc).unwrap();
-    make_exe(dir, path);
-
-    #[cfg(unix)]
-    fn make_exe(dir: &Path, bin: &Path) {
-        use std::os::unix::fs::PermissionsExt;
-        let mut perms = fs::metadata(dir).unwrap().permissions();
-        perms.set_mode(0o755);
-        fs::set_permissions(dir, perms).unwrap();
-        let mut perms = fs::metadata(bin).unwrap().permissions();
-        perms.set_mode(0o755);
-        fs::set_permissions(bin, perms).unwrap();
-    }
-
-    #[cfg(windows)]
-    fn make_exe(_: &Path, _: &Path) { }
+    for file in mock_bin("rustc", "1.0.0", "hash-c-2") {
+        file.build(&customdir.join("custom-2"));
+    }
 }
 
 pub fn hard_link<A, B>(a: A, b: B) -> io::Result<()>
diff --git a/src/rustup-mock/src/lib.rs b/src/rustup-mock/src/lib.rs
@@ -76,36 +76,15 @@ impl MockInstallerBuilder {
             // Create the component files and manifest
             let ref mut manifest = File::create(component_dir.join("manifest.in")).unwrap();
             for file in component.files.iter() {
-                let mk = |path: &Path, contents: &MockContents| {
-                    let dir_path = path.parent().unwrap().to_owned();
-                    fs::create_dir_all(dir_path).unwrap();
-                    File::create(&path).unwrap()
-                        .write_all(&contents.contents).unwrap();
-
-                    #[cfg(unix)]
-                    {
-                        use std::os::unix::fs::PermissionsExt;
-                        if contents.executable {
-                            let mut perm = fs::metadata(path).unwrap().permissions();
-                            perm.set_mode(0o755);
-                            fs::set_permissions(path, perm).unwrap();
-                        }
-                    }
-                };
                 match file.contents {
-                    Contents::Dir(ref files) => {
+                    Contents::Dir(_) => {
                         writeln!(manifest, "dir:{}", file.path).unwrap();
-                        for &(ref name, ref contents) in files {
-                            let fname = component_dir.join(&file.path).join(name);
-                            mk(&fname, contents);
-                        }
                     }
-                    Contents::File(ref contents) => {
+                    Contents::File(_) => {
                         writeln!(manifest, "file:{}", file.path).unwrap();
-                        let fname = component_dir.join(&file.path);
-                        mk(&fname, contents);
                     }
                 }
+                file.build(&component_dir);
             }
         }
 
@@ -152,6 +131,38 @@ impl MockFile {
         }
         self
     }
+
+    pub fn build(&self, path: &Path) {
+        let path = path.join(&self.path);
+        match self.contents {
+            Contents::Dir(ref files) => {
+                for &(ref name, ref contents) in files {
+                    let fname = path.join(name);
+                    contents.build(&fname);
+                }
+            }
+            Contents::File(ref contents) => contents.build(&path),
+        }
+    }
+}
+
+impl MockContents {
+    fn build(&self, path: &Path) {
+        let dir_path = path.parent().unwrap().to_owned();
+        fs::create_dir_all(dir_path).unwrap();
+        File::create(&path).unwrap()
+            .write_all(&self.contents).unwrap();
+
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            if self.executable {
+                let mut perm = fs::metadata(path).unwrap().permissions();
+                perm.set_mode(0o755);
+                fs::set_permissions(path, perm).unwrap();
+            }
+        }
+    }
 }
 
 #[cfg(windows)]
diff --git a/src/rustup-mock/src/mock_bin_src.rs b/src/rustup-mock/src/mock_bin_src.rs
@@ -1,14 +1,20 @@
 use std::env::consts::EXE_SUFFIX;
 use std::env;
-use std::io::{self, Write};
+use std::fs::File;
+use std::io::{self, Write, Read};
 use std::process::Command;
 
 fn main() {
     let mut args = env::args().skip(1);
     match args.next().as_ref().map(|s| &**s) {
         Some("--version") => {
-            let version = env!("EXAMPLE_VERSION");
-            let hash = env!("EXAMPLE_VERSION_HASH");
+            let me = env::current_exe().unwrap().display().to_string();
+            let version_file = format!("{}.version", me);
+            let hash_file = format!("{}.version-hash", me);
+            let mut version = String::new();
+            let mut hash = String::new();
+            File::open(&version_file).unwrap().read_to_string(&mut version).unwrap();
+            File::open(&hash_file).unwrap().read_to_string(&mut hash).unwrap();
             println!("{} ({})", version, hash);
         }
         Some("--empty-arg-test") => {
