aaai 0.40.0

Core engine for aaai — audit for asset integrity
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//! Definition file write locking — prevents concurrent saves.
//!
//! A lock file `<definition>.lock` is created before writing and removed
//! afterwards.  If the lock file already exists and is recent (< 60 s old),
//! the save is aborted with an error.

use std::path::Path;
use std::time::{Duration, SystemTime};

const LOCK_TTL: Duration = Duration::from_secs(60);
const LOCK_EXT: &str = "lock";

/// Acquire a write lock for `definition_path`.
///
/// Returns `Err` when the lock is already held by another process.
/// On success, returns a [`LockGuard`] that releases the lock on drop.
pub fn acquire(definition_path: &Path) -> anyhow::Result<LockGuard> {
    let lock_path = definition_path.with_extension(LOCK_EXT);

    if lock_path.exists() {
        // Check whether the lock is stale.
        if let Ok(meta) = std::fs::metadata(&lock_path) {
            if let Ok(modified) = meta.modified() {
                if SystemTime::now().duration_since(modified).unwrap_or_default() < LOCK_TTL {
                    anyhow::bail!(
                        "Definition file is locked by another process: {}.\n\
                         Delete {} to force-unlock.",
                        definition_path.display(),
                        lock_path.display()
                    );
                }
                // Stale lock — remove it.
                log::warn!("Removing stale lock: {}", lock_path.display());
                let _ = std::fs::remove_file(&lock_path);
            }
        }
    }

    std::fs::write(&lock_path, format!("pid:{}", std::process::id()))?;
    log::debug!("Lock acquired: {}", lock_path.display());
    Ok(LockGuard { lock_path })
}

/// RAII guard that releases the lock on drop.
#[must_use]
pub struct LockGuard {
    lock_path: std::path::PathBuf,
}

impl Drop for LockGuard {
    fn drop(&mut self) {
        if let Err(e) = std::fs::remove_file(&self.lock_path) {
            log::warn!("Could not remove lock file {}: {e}", self.lock_path.display());
        } else {
            log::debug!("Lock released: {}", self.lock_path.display());
        }
    }
}

#[cfg(test)]
mod tests;