filelock 0.7.0

Cross-platform file locking library for Rust
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

mod common;

use common::TestDir;
use filelock::FileLock;
use std::io::{BufRead, BufReader, Write};
use std::process::{Command, Stdio};
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

const CHILD_MODE: &str = "FILELOCK_PROCESS_TEST_CHILD";
const LOCK_PATH: &str = "FILELOCK_PROCESS_TEST_PATH";

#[test]
fn test_exclusive_lock_across_processes() {
    if std::env::var_os(CHILD_MODE).is_some() {
        run_holder_process();
        return;
    }

    let test_dir = TestDir::new("process");
    let path = test_dir.path("test.lock");
    let mut holder = Command::new(std::env::current_exe().unwrap())
        .args([
            "--exact",
            "test_exclusive_lock_across_processes",
            "--nocapture",
        ])
        .env(CHILD_MODE, "1")
        .env(LOCK_PATH, &path)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .unwrap();

    let stdout = holder.stdout.take().unwrap();
    let (locked_tx, locked_rx) = mpsc::channel();
    let output_reader = thread::spawn(move || {
        for line in BufReader::new(stdout).lines() {
            if line.unwrap() == "LOCKED" {
                let _ = locked_tx.send(());
            }
        }
    });

    if locked_rx.recv_timeout(Duration::from_secs(5)).is_err() {
        let _ = holder.kill();
        let _ = holder.wait();
        output_reader.join().unwrap();
        panic!("holder process did not acquire the file lock");
    }

    let mut contender = FileLock::new(&path).unwrap();
    let unavailable_while_held = contender.try_lock().unwrap().is_none();

    writeln!(holder.stdin.take().unwrap(), "RELEASE").unwrap();
    let status = holder.wait().unwrap();
    output_reader.join().unwrap();

    let available_after_release = contender.try_lock().unwrap().is_some();
    assert!(status.success(), "holder process failed: {status}");
    assert!(
        unavailable_while_held,
        "another process acquired an already-held file lock"
    );
    assert!(
        available_after_release,
        "file lock remained unavailable after the holder exited"
    );
}

fn run_holder_process() {
    let path = std::env::var_os(LOCK_PATH).unwrap();
    let mut lock = FileLock::new(path).unwrap();
    let _guard = lock.lock().unwrap();

    println!("LOCKED");
    std::io::stdout().flush().unwrap();

    let mut command = String::new();
    std::io::stdin().read_line(&mut command).unwrap();
    assert_eq!(command.trim(), "RELEASE");
}