void_core/support/

lock.rs

//! Repository lock for mutating operations.

use std::fs::{self, File, OpenOptions};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};

use super::error::{Result, VoidError};

const LOCK_FILENAME: &str = "LOCK";

/// Information about a stale lock (process no longer running).
pub struct StaleLockInfo {
    pub pid: u32,
    pub created: u64,
    pub path: PathBuf,
}

/// A guard that holds the repository lock until dropped.
pub struct RepoLock {
    path: PathBuf,
    file: Option<File>,
}

impl RepoLock {
    /// Acquire the repository lock, optionally forcing removal of a stale lock.
    pub fn acquire(void_dir: &Path, force: bool) -> Result<Self> {
        let path = void_dir.join(LOCK_FILENAME);

        if force && path.exists() {
            fs::remove_file(&path)?;
        }

        let mut file = match OpenOptions::new().write(true).create_new(true).open(&path) {
            Ok(file) => file,
            Err(err) => {
                if err.kind() == std::io::ErrorKind::AlreadyExists {
                    return Err(VoidError::RepoLocked(path.display().to_string()));
                }
                return Err(VoidError::Io(err));
            }
        };

        let pid = std::process::id();
        let created = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
        let content = format!("pid={pid}\ncreated={created}\n");
        if let Err(err) = file.write_all(content.as_bytes()) {
            let _ = fs::remove_file(&path);
            return Err(VoidError::Io(err));
        }

        Ok(Self {
            path,
            file: Some(file),
        })
    }

    /// Check if an existing lock is stale (process no longer running).
    pub fn is_stale(void_dir: &Path) -> Result<Option<StaleLockInfo>> {
        let path = void_dir.join(LOCK_FILENAME);
        if !path.exists() {
            return Ok(None);
        }

        let content = fs::read_to_string(&path)?;
        let pid = parse_pid(&content)?;
        let created = parse_created(&content)?;

        if !is_process_running(pid) {
            return Ok(Some(StaleLockInfo { pid, created, path }));
        }

        Ok(None)
    }

    /// Acquire lock, automatically removing stale locks.
    pub fn acquire_auto(void_dir: &Path) -> Result<Self> {
        if let Some(stale) = Self::is_stale(void_dir)? {
            // Remove stale lock
            let _ = fs::remove_file(&stale.path);
        }
        Self::acquire(void_dir, false)
    }
}

fn parse_pid(content: &str) -> Result<u32> {
    content
        .lines()
        .find(|l| l.starts_with("pid="))
        .and_then(|l| l.strip_prefix("pid="))
        .and_then(|s| s.parse().ok())
        .ok_or_else(|| VoidError::Lock("invalid lock file format".into()))
}

fn parse_created(content: &str) -> Result<u64> {
    content
        .lines()
        .find(|l| l.starts_with("created="))
        .and_then(|l| l.strip_prefix("created="))
        .and_then(|s| s.parse().ok())
        .ok_or_else(|| VoidError::Lock("invalid lock file format".into()))
}

#[cfg(unix)]
fn is_process_running(pid: u32) -> bool {
    // kill(pid, 0) checks if process exists without sending signal
    // Returns 0 if process exists, -1 if not
    unsafe { libc::kill(pid as i32, 0) == 0 }
}

#[cfg(windows)]
fn is_process_running(pid: u32) -> bool {
    // OpenProcess returns 0 (null handle) if process doesn't exist.
    // HANDLE is isize on Windows — compare to 0, not .is_null().
    const PROCESS_QUERY_LIMITED_INFORMATION: u32 = 0x1000;
    extern "system" {
        fn OpenProcess(access: u32, inherit: i32, pid: u32) -> isize;
        fn CloseHandle(handle: isize) -> i32;
    }
    let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
    if handle == 0 {
        false
    } else {
        unsafe { CloseHandle(handle) };
        true
    }
}

#[cfg(not(any(unix, windows)))]
fn is_process_running(_pid: u32) -> bool {
    // Fallback: assume process is running (conservative)
    true
}

impl Drop for RepoLock {
    fn drop(&mut self) {
        let _ = self.file.take();
        let _ = fs::remove_file(&self.path);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn stale_lock_detected_when_pid_not_running() {
        let temp = tempfile::TempDir::new().unwrap();
        let void_dir = temp.path();

        // Create lock file with non-existent PID
        let lock_path = void_dir.join("LOCK");
        fs::write(&lock_path, "pid=999999999\ncreated=1234567890\n").unwrap();

        // Should detect as stale
        let stale = RepoLock::is_stale(void_dir).unwrap();
        assert!(stale.is_some());
        assert_eq!(stale.unwrap().pid, 999999999);
    }

    #[test]
    fn active_lock_not_considered_stale() {
        let temp = tempfile::TempDir::new().unwrap();
        let void_dir = temp.path();

        // Create lock file with current process PID
        let lock_path = void_dir.join("LOCK");
        let content = format!("pid={}\ncreated=1234567890\n", std::process::id());
        fs::write(&lock_path, content).unwrap();

        // Should NOT be stale
        let stale = RepoLock::is_stale(void_dir).unwrap();
        assert!(stale.is_none());
    }

    #[test]
    fn acquire_auto_removes_stale_lock() {
        let temp = tempfile::TempDir::new().unwrap();
        let void_dir = temp.path();

        // Create stale lock
        let lock_path = void_dir.join("LOCK");
        fs::write(&lock_path, "pid=999999999\ncreated=1234567890\n").unwrap();

        // acquire_auto should succeed by removing stale lock
        let lock = RepoLock::acquire_auto(void_dir).unwrap();

        // Lock should be held
        assert!(lock_path.exists());

        drop(lock);
    }

    #[test]
    fn no_lock_returns_none() {
        let temp = tempfile::TempDir::new().unwrap();
        let void_dir = temp.path();

        // No lock file exists
        let stale = RepoLock::is_stale(void_dir).unwrap();
        assert!(stale.is_none());
    }

    #[test]
    fn parse_pid_works() {
        let content = "pid=12345\ncreated=1234567890\n";
        assert_eq!(parse_pid(content).unwrap(), 12345);
    }

    #[test]
    fn parse_created_works() {
        let content = "pid=12345\ncreated=1234567890\n";
        assert_eq!(parse_created(content).unwrap(), 1234567890);
    }

    #[test]
    fn invalid_lock_format_returns_error() {
        let content = "invalid format";
        assert!(parse_pid(content).is_err());
        assert!(parse_created(content).is_err());
    }
}