grit-lib 0.5.21

Core library for the grit Git implementation
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
84
85
86
87
88
89
90
91
92
93
94

//! Ref lock backoff when another process briefly holds `refs/heads/*.lock`.

mod support;

use std::sync::{Arc, Barrier};
use std::thread;
use std::time::{Duration, Instant};

use grit_lib::error::Error;
use grit_lib::refs::store::RefStoreError;
use grit_lib::refs::{lock_path_for_ref, write_ref};

use support::{
    assert_fsck_when_git_interop, files_repo, git, git_empty_commit_oid, git_interop_available,
    Backend,
};

#[test]
fn lockfile_contention_git_compat_succeeds_within_default_budget() {
    if !git_interop_available(Backend::Files) {
        return;
    }
    let repo = files_repo();
    let git_dir = repo.git_dir();
    let base = git_empty_commit_oid(repo.worktree());
    write_ref(&git_dir, "refs/heads/main", &base).expect("seed main");

    let ref_path = git_dir.join("refs/heads/contended");
    let lock_path = lock_path_for_ref(&ref_path);
    if let Some(parent) = ref_path.parent() {
        std::fs::create_dir_all(parent).expect("ref parent");
    }

    let start = Barrier::new(2);
    let lock_path_thread = lock_path.clone();
    let starter = Arc::new(start);
    let starter_child = Arc::clone(&starter);
    let holder = thread::spawn(move || {
        std::fs::write(&lock_path_thread, b"").expect("foreign lock");
        starter_child.wait();
        thread::sleep(Duration::from_millis(50));
        std::fs::remove_file(&lock_path_thread).expect("release foreign lock");
    });

    starter.wait();
    let began = Instant::now();
    write_ref(&git_dir, "refs/heads/contended", &base).expect("write after brief contention");
    assert!(
        began.elapsed() < Duration::from_millis(500),
        "ref update should not block far beyond the default lock budget"
    );
    holder.join().expect("holder thread");

    assert!(ref_path.is_file());
    assert_fsck_when_git_interop(&repo);
}

#[test]
fn lockfile_contention_held_forever_preserves_foreign_lock() {
    if !git_interop_available(Backend::Files) {
        return;
    }
    let repo = files_repo();
    let git_dir = repo.git_dir();
    let base = git_empty_commit_oid(repo.worktree());
    write_ref(&git_dir, "refs/heads/main", &base).expect("seed main");

    let ref_path = git_dir.join("refs/heads/blocked");
    let lock_path = lock_path_for_ref(&ref_path);
    if let Some(parent) = ref_path.parent() {
        std::fs::create_dir_all(parent).expect("ref parent");
    }
    std::fs::write(&lock_path, b"foreign\n").expect("foreign lock");

    let err = write_ref(&git_dir, "refs/heads/blocked", &base).expect_err("budget exhausted");
    assert!(
        matches!(
            &err,
            Error::Io(e) if e.kind() == std::io::ErrorKind::AlreadyExists
        ) || matches!(&err, Error::RefStore(RefStoreError::LockHeld { .. })),
        "unexpected error: {err:?}"
    );
    assert_eq!(
        std::fs::read_to_string(&lock_path).expect("foreign lock still present"),
        "foreign\n"
    );

    std::fs::remove_file(&lock_path).expect("clear foreign lock for git");
    git(
        repo.worktree(),
        &["update-ref", "refs/heads/blocked", &base.to_hex()],
    );
    assert_fsck_when_git_interop(&repo);
}