Remove build.lock when finished

Author: rolandpeelen

rewatch/src/build.rs

@@ -14,7 +14,7 @@ use crate::build::compile::{mark_modules_with_deleted_deps_dirty, mark_modules_w
 use crate::build::compiler_info::{CompilerCheckResult, verify_compiler_info, write_compiler_info};
 use crate::helpers::emojis::*;
 use crate::helpers::{self};
-use crate::lock::{LockKind, get_lock_or_exit};
+use crate::lock::{LockKind, drop_lock, get_lock_or_exit};
 use crate::project_context::ProjectContext;
 use crate::sourcedirs;
 use anyhow::{Context, Result, anyhow};
@@ -147,7 +147,13 @@ pub fn initialize_build(
         return Err(anyhow!("Failed to validate package dependencies"));
     }
 
-    let mut build_state = BuildCommandState::new(project_context, packages, compiler, warn_error);
+    let mut build_state = BuildCommandState::new(
+        path.to_path_buf(),
+        project_context,
+        packages,
+        compiler,
+        warn_error,
+    );
     packages::parse_packages(&mut build_state)?;
 
     let compile_assets_state = read_compile_state::read(&mut build_state)?;
@@ -239,6 +245,10 @@ pub fn incremental_build(
     create_sourcedirs: bool,
     plain_output: bool,
 ) -> Result<(), IncrementalBuildError> {
+    let build_folder = build_state.root_folder.to_string_lossy().to_string();
+
+    let _lock = get_lock_or_exit(LockKind::Build, &build_folder);
+
     logs::initialize(&build_state.packages);
     let num_dirty_modules = build_state.modules.values().filter(|m| is_dirty(m)).count() as u64;
     let pb = if !plain_output && show_progress {
@@ -282,6 +292,8 @@ pub fn incremental_build(
             }
 
             eprintln!("{}", &err);
+            let _lock = drop_lock(LockKind::Build, &build_folder);
+
             return Err(IncrementalBuildError {
                 kind: IncrementalBuildErrorKind::SourceFileParseError,
                 plain_output,
@@ -344,9 +356,13 @@ pub fn incremental_build(
         || pb.inc(1),
         |size| pb.set_length(size),
     )
-    .map_err(|e| IncrementalBuildError {
-        kind: IncrementalBuildErrorKind::CompileError(Some(e.to_string())),
-        plain_output,
+    .map_err(|e| {
+        let _lock = drop_lock(LockKind::Build, &build_folder);
+
+        IncrementalBuildError {
+            kind: IncrementalBuildErrorKind::CompileError(Some(e.to_string())),
+            plain_output,
+        }
     })?;
 
     let compile_duration = start_compiling.elapsed();
@@ -380,6 +396,9 @@ pub fn incremental_build(
         if helpers::contains_ascii_characters(&compile_errors) {
             eprintln!("{}", &compile_errors);
         }
+
+        let _lock = drop_lock(LockKind::Build, &build_folder);
+
         Err(IncrementalBuildError {
             kind: IncrementalBuildErrorKind::CompileError(None),
             plain_output,
@@ -410,6 +429,7 @@ pub fn incremental_build(
         // Write per-package compiler metadata to `lib/bs/compiler-info.json` (idempotent)
         write_compiler_info(build_state);
 
+        let _lock = drop_lock(LockKind::Build, &build_folder);
         Ok(())
     }
 }
@@ -470,8 +490,6 @@ pub fn build(
     plain_output: bool,
     warn_error: Option<String>,
 ) -> Result<BuildCommandState> {
-    let _lock = get_lock_or_exit(LockKind::Build, &path.to_string_lossy());
-
     let default_timing: Option<std::time::Duration> = if no_timing {
         Some(std::time::Duration::new(0.0 as u64, 0.0 as u32))
     } else {

rewatch/src/build/build_types.rs

@@ -122,6 +122,7 @@ pub struct BuildState {
 /// - This prevents the "code smell" of optional fields that are None for some commands
 #[derive(Debug)]
 pub struct BuildCommandState {
+    pub root_folder: PathBuf,
     pub build_state: BuildState,
     // Command-line --warn-error flag override (takes precedence over rescript.json config)
     pub warn_error_override: Option<String>,
@@ -171,12 +172,14 @@ impl BuildState {
 
 impl BuildCommandState {
     pub fn new(
+        root_folder: PathBuf,
         project_context: ProjectContext,
         packages: AHashMap<String, Package>,
         compiler: CompilerInfo,
         warn_error_override: Option<String>,
     ) -> Self {
         Self {
+            root_folder,
             build_state: BuildState::new(project_context, packages, compiler),
             warn_error_override,
         }

rewatch/src/lock.rs

@@ -35,7 +35,7 @@ pub enum Error {
     Locked(u32),
     AwaitingLockFile(AwaitLockError),
     ParsingLockfile(std::num::ParseIntError),
-    ReadingLockfile(std::io::Error),
+    ReadingLockfile(LockKind, std::io::Error),
     WritingLockfile(std::io::Error),
     ProjectFolderMissing(std::path::PathBuf),
 }
@@ -49,8 +49,11 @@ impl std::fmt::Display for Error {
             Error::ParsingLockfile(e) => format!(
                 "Could not parse lockfile: \n {e} \n  (try removing it and running the command again)"
             ),
-            Error::ReadingLockfile(e) => {
-                format!("Could not read lockfile: \n {e} \n  (try removing it and running the command again)")
+            Error::ReadingLockfile(kind, e) => {
+                format!(
+                    "Could not read lockfile: {}, \n {e} \n  (try removing it and running the command again)",
+                    kind.file_name()
+                )
             }
             Error::WritingLockfile(e) => format!("Could not write lockfile: \n {e}"),
             Error::ProjectFolderMissing(path) => format!(
@@ -113,7 +116,7 @@ impl LockKind {
 
 pub const TIMEOUT_SECONDS: u64 = 60;
 
-pub fn await_lock_deletion(location: &Path) -> Result<(), Error> {
+pub fn await_lock_deletion(location: &Path, kind: LockKind) -> Result<(), Error> {
     let now = SystemTime::now();
     let queue = Arc::new(FifoQueue::<Result<Event, notify::Error>>::new());
     let producer = queue.clone();
@@ -127,12 +130,13 @@ pub fn await_lock_deletion(location: &Path) -> Result<(), Error> {
 
     loop {
         while !queue.is_empty() {
-            if let Ok(Event {
-                kind: EventKind::Remove(_),
-                ..
-            }) = queue.pop()
-            {
-                return Ok(());
+            match queue.pop() {
+                Ok(Event {
+                    kind: EventKind::Remove(_),
+                    paths,
+                    ..
+                }) if paths.iter().find(|p| p.ends_with(kind.file_name())).is_some() => return Ok(()),
+                Ok(_) | Err(_) => (),
             }
         }
 
@@ -167,7 +171,7 @@ pub fn get(kind: LockKind, folder: &str) -> Lock {
                 Ok(parsed_pid) if pid_matches_current_process(parsed_pid) => match kind {
                     LockKind::Build => {
                         println!("Awaiting lockfile");
-                        match await_lock_deletion(&location) {
+                        match await_lock_deletion(&lib_dir, kind) {
                             Ok(_) => {
                                 continue;
                             }
@@ -180,7 +184,7 @@ pub fn get(kind: LockKind, folder: &str) -> Lock {
                 Err(e) => return Lock::Error(Error::ParsingLockfile(e)),
             },
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => break,
-            Err(e) => return Lock::Error(Error::ReadingLockfile(e)),
+            Err(e) => return Lock::Error(Error::ReadingLockfile(kind, e)),
         }
     }
 
@@ -201,14 +205,28 @@ pub fn get(kind: LockKind, folder: &str) -> Lock {
 pub fn get_lock_or_exit(kind: LockKind, folder: &str) -> Lock {
     match get(kind, folder) {
         Lock::Error(error) => {
-            eprintln!("Could not start ReScript build: {error}");
+            eprintln!("Could not start Rescript build: {error}");
             std::process::exit(1);
         }
 
         acquired_lock => acquired_lock,
     }
 }
 
+pub fn drop_lock(kind: LockKind, folder: &str) -> Result<()> {
+    let project_folder = Path::new(folder);
+    if !project_folder.exists() {
+        return Ok(());
+    }
+
+    let lib_dir = project_folder.join("lib");
+    let location = lib_dir.join(kind.file_name());
+
+    fs::remove_file(&location)?;
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;