RFC: Globally Locked Cargo

Cargo.toml

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

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, human,
+                  ChainError};
 
 #[derive(RustcDecodable)]
 struct Flags {
@@ -91,6 +92,13 @@ 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!(CargoLock::lock_kind(config)));
+
+    try!(fl.lock().chain_error(|| {
+        human("Failed to obtain global cargo lock")
+    }));
+
     try!(config.shell().set_verbosity(flags.flag_verbose, flags.flag_quiet));
 
     init_git_transports(config);

src/cargo/lib.rs

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

src/cargo/util/lock.rs

@@ -0,0 +1,92 @@
+use file_lock::filename::{Mode, ParseError};
+use file_lock::filename::Lock as FileLock;
+use file_lock::filename::Error as FileLockError;
+
+use std::path::PathBuf;
+use std::fs;
+use std::thread::sleep_ms;
+
+use util::{Config, CargoError, CargoResult, human, caused_human};
+
+pub use file_lock::filename::Kind as LockKind;
+
+impl From<FileLockError> for Box<CargoError> {
+    fn from(t: FileLockError) -> Self {
+        Box::new(t)
+    }
+}
+
+impl From<ParseError> for Box<CargoError> {
+    fn from(t: ParseError) -> Self {
+        Box::new(t)
+    }
+}
+
+impl CargoError for FileLockError {
+    fn is_human(&self) -> bool { true }
+}
+impl CargoError for ParseError {}
+
+pub struct CargoLock {
+    kind: LockKind, 
+    inner: FileLock,
+}
+
+impl CargoLock {
+
+    pub fn lock_kind(config: &Config) -> CargoResult<LockKind> {
+        // TODO(ST): rename config key to something more suitable
+        const CONFIG_KEY: &'static str = "build.lock-kind";
+        match try!(config.get_string(CONFIG_KEY)).map(|t| t.0) {
+            None => Ok(LockKind::NonBlocking),
+            Some(kind_string) => match kind_string.parse() {
+                Ok(kind) => Ok(kind),
+                Err(_) => Err(human(format!("Failed to parse value '{}' at configuration key \
+                                            '{}'. Must be one of '{}' and '{}'",
+                                            kind_string, CONFIG_KEY,
+                                            LockKind::NonBlocking.as_ref(), 
+                                            LockKind::Blocking.as_ref())))
+            }
+        }
+    }
+
+    pub fn new(path: PathBuf, kind: LockKind) -> CargoLock {
+        CargoLock {
+            kind: kind,
+            inner: FileLock::new(path, Mode::Write)
+        }
+    }
+
+    pub fn new_shared(path: PathBuf, kind: LockKind) -> CargoLock {
+        CargoLock {
+            kind: kind,
+            inner: FileLock::new(path, Mode::Read)
+        }
+    }
+
+    pub fn lock(&mut self) -> CargoResult<()> {
+        // NOTE(ST): This could fail if cargo is run concurrently for the first time
+        // The only way to prevent it would be to take a lock in a directory which exists.
+        // This is why we don't try! here, but hope the directory exists when we 
+        // try to create the lock file
+        {
+            let lock_dir = self.inner.path().parent().unwrap();
+            if let Err(_) = fs::create_dir_all(lock_dir) {
+                // We might compete to create one or more directories here
+                // Give the competing process some time to finish. Then we will
+                // retry, hoping it the creation works (maybe just because the )
+                // directory is available already.
+                // TODO(ST): magic numbers, especially in sleep, will fail at some point ... .
+                sleep_ms(100);
+                if let Err(io_err) = fs::create_dir_all(lock_dir) {
+                    // Fail permanently if it still didn't work ... 
+                    return Err(caused_human(format!("Failed to create parent directory of \
+                                                     lock-file at '{}'", 
+                                                     lock_dir.display()), io_err));
+                }
+            }
+        }
+        debug!("About to acquire file lock: '{}'", self.inner.path().display());
+        Ok(try!(self.inner.any_lock(self.kind.clone())))
+    }
+}

src/cargo/util/mod.rs

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

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 mut 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#"