RFC: Globally Locked Cargo

Cargo.toml

@@ -43,6 +43,10 @@ toml = "0.1"
 url = "0.2"
 winapi = "0.2"
 
+[dependencies.file-lock]
+git = "https://github.com/Byron/file-lock"
+branch = "cargo-adjustments"
+
 [dev-dependencies]
 tempdir = "0.3"
 hamcrest = "0.1"

src/bin/cargo.rs

@@ -14,7 +14,8 @@ use std::process::Command;
 
 use cargo::{execute_main_without_stdin, handle_error, shell};
 use cargo::core::MultiShell;
-use cargo::util::{CliError, CliResult, lev_distance, Config};
+use cargo::util::{CliError, CliResult, lev_distance, Config, CargoLock, LockKind, human,
+                  ChainError};
 
 #[derive(RustcDecodable)]
 struct Flags {
@@ -95,6 +96,12 @@ macro_rules! each_subcommand{ ($mac:ident) => ({
   on this top-level information.
 */
 fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
+    let mut fl = CargoLock::new(config.home().join(".global-lock"));
+
+    try!(fl.lock(LockKind::Blocking).chain_error(|| {
+        human("Failed to obtain global cargo lock")
+    }));
+
     try!(config.shell().set_verbosity(flags.flag_verbose, flags.flag_quiet));
     try!(config.shell().set_color_config(flags.flag_color.as_ref().map(|s| &s[..])));
 

src/cargo/lib.rs

@@ -22,6 +22,7 @@ extern crate term;
 extern crate time;
 extern crate toml;
 extern crate url;
+extern crate file_lock;
 
 use std::env;
 use std::error::Error;

src/cargo/util/errors.rs

@@ -12,6 +12,7 @@ use curl;
 use git2;
 use toml;
 use url;
+use file_lock;
 
 pub type CargoResult<T> = Result<T, Box<CargoError>>;
 
@@ -307,12 +308,18 @@ from_error! {
     url::ParseError,
     toml::DecodeError,
     ffi::NulError,
+    file_lock::filename::Error,
+    file_lock::filename::ParseError,
 }
 
 impl<E: CargoError> From<Human<E>> for Box<CargoError> {
     fn from(t: Human<E>) -> Box<CargoError> { Box::new(t) }
 }
 
+impl CargoError for file_lock::filename::Error {
+    fn is_human(&self) -> bool { true }
+}
+
 impl CargoError for semver::ReqParseError {}
 impl CargoError for io::Error {}
 impl CargoError for git2::Error {}
@@ -325,6 +332,7 @@ impl CargoError for toml::Error {}
 impl CargoError for toml::DecodeError {}
 impl CargoError for url::ParseError {}
 impl CargoError for ffi::NulError {}
+impl CargoError for file_lock::filename::ParseError {}
 
 // =============================================================================
 // Construction helpers

src/cargo/util/lock.rs

@@ -0,0 +1,33 @@
+use file_lock::filename::Mode;
+use file_lock::filename::Lock as FileLock;
+
+use std::path::PathBuf;
+use std::fs;
+
+use util::{CargoResult, ChainError, human};
+
+pub use file_lock::filename::Kind as LockKind;
+
+pub struct CargoLock {
+    inner: FileLock,
+}
+
+impl CargoLock {
+    pub fn new(path: PathBuf) -> CargoLock {
+        CargoLock {
+            inner: FileLock::new(path, Mode::Write)
+        }
+    }
+
+    pub fn lock(&mut self, kind: LockKind) -> CargoResult<()> {
+        {
+            let lock_dir = self.inner.path().parent().unwrap();
+            try!(fs::create_dir_all(lock_dir).chain_error(|| { 
+                human(format!("Failed to create parent directory of lock-file at '{}'",
+                              lock_dir.display()))
+            }));
+        }
+        debug!("About to acquire file lock: '{}'", self.inner.path().display());
+        Ok(try!(self.inner.any_lock(kind)))
+    }
+}

src/cargo/util/mod.rs

@@ -16,6 +16,7 @@ pub use self::sha256::Sha256;
 pub use self::to_semver::ToSemver;
 pub use self::to_url::ToUrl;
 pub use self::vcs::{GitRepo, HgRepo};
+pub use self::lock::{CargoLock, LockKind};
 
 pub mod config;
 pub mod errors;
@@ -33,4 +34,5 @@ mod dependency_queue;
 mod sha256;
 mod shell_escape;
 mod vcs;
+mod lock;
 mod rustc;

tests/test_cargo_build_lib.rs

@@ -53,6 +53,32 @@ test!(build_with_no_lib {
                        .with_stderr("no library targets found"));
 });
 
+test!(build_global_lock {
+
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+
+            name = "foo"
+            version = "0.0.1"
+            authors = ["[email protected]"]
+        "#)
+        .file("src/main.rs", r#"
+            fn main() {}
+        "#)
+        .file("src/lib.rs", r#" "#);
+
+    p.build();
+
+    let bg_process = p.cargo("build");
+    let fg_process = bg_process.clone();
+    let mut bg_process_handle = bg_process.build_command().spawn().unwrap();
+
+    assert_eq!(fg_process.build_command().output().unwrap().status.code().unwrap(), 101);
+    assert!(bg_process_handle.wait().unwrap().success());
+});
+
+
 test!(build_with_relative_cargo_home_path {
     let p = project("foo")
         .file("Cargo.toml", r#"