implement primitive file-based project lock

Author: ethangreen-dev

Cargo.lock

@@ -19,7 +19,11 @@ indicatif = { version = "0.17.8", features = ["improved_unicode", "tokio"] }
 # async runtime and helpers
 futures = "0.3"
 futures-util = "0.3"
-tokio = { version = "1.34", features = ["macros", "process", "rt-multi-thread"]}
+tokio = { version = "1.34", features = [
+    "macros",
+    "process",
+    "rt-multi-thread",
+] }
 tokio-util = { version = "0.7", features = ["io"] }
 async-compression = { version = "0.4", features = ["futures-io", "gzip"] }
 
@@ -45,3 +49,6 @@ log = "0.4.21"
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.50"
+
+[dev-dependencies]
+tempfile = "3.10"

Cargo.toml

@@ -1,31 +1,61 @@
 use std::fs::{self, File};
 use std::path::{Path, PathBuf};
 
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    #[error("The lock at {0:?} is already acquired by a process with PID {1}.")]
-    InUse(PathBuf, u32),
-}
-
 /// Only one server process can "own" a project at a single time.
 /// We enforce this exclusive access through the creation and deletion of this lockfile.
 const LOCKFILE: &'static str = ".server-lock";
 
-pub struct ProjectLock<'a> {
+pub struct ProjectLock {
     file: File,
-    path: &'a Path,
+    path: PathBuf,
 }
 
-impl<'a> ProjectLock<'_> {
+impl ProjectLock {
     /// Attempt to acquire a lock on the provided directory.
-    pub fn lock(project_path: &'a Path) -> Result<Self, Error> {
-        todo!()
+    pub fn lock(project_path: &Path) -> Option<Self> {
+        let lock = project_path.join(LOCKFILE);
+        match lock.is_file() {
+            true => None,
+            false => {
+                let file = File::create(&lock).ok()?;
+                Some(Self { file, path: lock })
+            }
+        }
     }
 }
 
-impl Drop for ProjectLock<'_> {
+impl Drop for ProjectLock {
     fn drop(&mut self) {
         // The file handle is dropped before this, so we can safely delete it.
-        fs::remove_file(self.path);
+        fs::remove_file(&self.path).unwrap();
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use tempfile::TempDir;
+
+    /// Test that project locks behave in the following way:
+    /// - Attempting to lock an already locked project MUST return None.
+    /// - Attempting to lock a project that is not locked will return a ProjectLock.
+    /// - Dropping a ProjectLock will remove the lockfile from the project.
+    #[test]
+    fn test_project_lock() {
+        let temp = TempDir::new().unwrap();
+        let root = temp.path();
+
+        // Acquire a lock on the directory.
+        {
+            let _lock =
+                ProjectLock::lock(root).expect("Failed to acquire lock on empty directory.");
+
+            // Attempting to acquire it again will return None.
+            let relock = ProjectLock::lock(root);
+            assert!(relock.is_none());
+        }
+
+        // Now that the previous lock is dropped we *should* be able to re-acquire it.
+        let _lock = ProjectLock::lock(root).expect("Failed to acquire lock on empty directory.");
     }
 }

src/server/lock.rs

@@ -5,6 +5,7 @@ use std::{io, thread};
 
 use self::proto::{Message, Request, Response};
 
+mod lock;
 mod method;
 mod proto;
 mod route;