mirror of
https://github.com/git/git
synced 2024-08-27 11:39:22 +00:00
![Jeff King](/assets/img/avatar_default.png)
We pass our prune expiration to mark_reachable_objects(), which will traverse not only the reachable objects, but consider any recent ones as tips for reachability; seed3038d22f9
(prune: keep objects reachable from recent objects, 2014-10-15) for details. However, this interacts badly with the bitmap code path added infde67d6896
(prune: use bitmaps for reachability traversal, 2019-02-13). If we hit the bitmap-optimized path, we return immediately to avoid the regular traversal, accidentally skipping the "also traverse recent" code. Instead, we should do an if-else for the bitmap versus regular traversal, and then follow up with the "recent" traversal in either case. This reuses the "rev_info" for a bitmap and then a regular traversal, but that should work OK (the bitmap code clears the pending array in the usual way, just like a regular traversal would). Note that I dropped the comment above the regular traversal here. It has little explanatory value, and makes the if-else logic much harder to read. Here are a few variants that I rejected: - it seems like both the reachability and recent traversals could be done in a single traversal. This was rejected byd3038d22f9
(prune: keep objects reachable from recent objects, 2014-10-15), though the balance may be different when using bitmaps. However, there's a subtle correctness issue, too: we use revs->ignore_missing_links for the recent traversal, but not the reachability one. - we could try using bitmaps for the recent traversal, too, which could possibly improve performance. But it would require some fixes in the bitmap code, which uses ignore_missing_links for its own purposes. Plus it would probably not help all that much in practice. We use the reachable tips to generate bitmaps, so those objects are likely not covered by bitmaps (unless they just became unreachable). And in general, we expect the set of unreachable objects to be much smaller anyway, so there's less to gain. The test in t5304 detects the bug and confirms the fix. I also beefed up the tests in t6501, which covers the mtime-checking code more thoroughly, to handle the bitmap case (in addition to just "loose" and "packed" cases). Interestingly, this test doesn't actually detect the bug, because it is running "git gc", and not "prune" directly. And "gc" will call "repack" first, which does not suffer the same bug. So the old-but-reachable-from-recent objects get scooped up into the new pack along with the actually-recent objects, which gives both a recent mtime. But it seemed prudent to get more coverage of the bitmap case for related code. Reported-by: David Emett <dave@sp4m.net> Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
184 lines
4.5 KiB
Bash
Executable file
184 lines
4.5 KiB
Bash
Executable file
#!/bin/sh
|
|
#
|
|
# This test covers the handling of objects which might have old
|
|
# mtimes in the filesystem (because they were used previously)
|
|
# and are just now becoming referenced again.
|
|
#
|
|
# We're going to do two things that are a little bit "fake" to
|
|
# help make our simulation easier:
|
|
#
|
|
# 1. We'll turn off reflogs. You can still run into
|
|
# problems with reflogs on, but your objects
|
|
# don't get pruned until both the reflog expiration
|
|
# has passed on their references, _and_ they are out
|
|
# of prune's expiration period. Dropping reflogs
|
|
# means we only have to deal with one variable in our tests,
|
|
# but the results generalize.
|
|
#
|
|
# 2. We'll use a temporary index file to create our
|
|
# works-in-progress. Most workflows would mention
|
|
# referenced objects in the index, which prune takes
|
|
# into account. However, many operations don't. For
|
|
# example, a partial commit with "git commit foo"
|
|
# will use a temporary index. Or they may not need
|
|
# an index at all (e.g., creating a new commit
|
|
# to refer to an existing tree).
|
|
|
|
test_description='check pruning of dependent objects'
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
|
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
|
|
|
. ./test-lib.sh
|
|
|
|
# We care about reachability, so we do not want to use
|
|
# the normal test_commit, which creates extra tags.
|
|
add () {
|
|
echo "$1" >"$1" &&
|
|
git add "$1"
|
|
}
|
|
commit () {
|
|
test_tick &&
|
|
add "$1" &&
|
|
git commit -m "$1"
|
|
}
|
|
|
|
maybe_repack () {
|
|
case "$title" in
|
|
loose)
|
|
: skip repack
|
|
;;
|
|
repack)
|
|
git repack -ad
|
|
;;
|
|
bitmap)
|
|
git repack -adb
|
|
;;
|
|
*)
|
|
echo >&2 "unknown test type in maybe_repack"
|
|
return 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
for title in loose repack bitmap
|
|
do
|
|
test_expect_success "make repo completely empty ($title)" '
|
|
rm -rf .git &&
|
|
git init
|
|
'
|
|
|
|
test_expect_success "disable reflogs ($title)" '
|
|
git config core.logallrefupdates false &&
|
|
git reflog expire --expire=all --all
|
|
'
|
|
|
|
test_expect_success "setup basic history ($title)" '
|
|
commit base
|
|
'
|
|
|
|
test_expect_success "create and abandon some objects ($title)" '
|
|
git checkout -b experiment &&
|
|
commit abandon &&
|
|
maybe_repack &&
|
|
git checkout main &&
|
|
git branch -D experiment
|
|
'
|
|
|
|
test_expect_success "simulate time passing ($title)" '
|
|
test-tool chmtime --get -86400 $(find .git/objects -type f)
|
|
'
|
|
|
|
test_expect_success "start writing new commit with old blob ($title)" '
|
|
tree=$(
|
|
GIT_INDEX_FILE=index.tmp &&
|
|
export GIT_INDEX_FILE &&
|
|
git read-tree HEAD &&
|
|
add unrelated &&
|
|
add abandon &&
|
|
git write-tree
|
|
)
|
|
'
|
|
|
|
test_expect_success "simultaneous gc ($title)" '
|
|
git gc --prune=12.hours.ago
|
|
'
|
|
|
|
test_expect_success "finish writing out commit ($title)" '
|
|
commit=$(echo foo | git commit-tree -p HEAD $tree) &&
|
|
git update-ref HEAD $commit
|
|
'
|
|
|
|
# "abandon" blob should have been rescued by reference from new tree
|
|
test_expect_success "repository passes fsck ($title)" '
|
|
git fsck
|
|
'
|
|
|
|
test_expect_success "abandon objects again ($title)" '
|
|
git reset --hard HEAD^ &&
|
|
test-tool chmtime --get -86400 $(find .git/objects -type f)
|
|
'
|
|
|
|
test_expect_success "start writing new commit with same tree ($title)" '
|
|
tree=$(
|
|
GIT_INDEX_FILE=index.tmp &&
|
|
export GIT_INDEX_FILE &&
|
|
git read-tree HEAD &&
|
|
add abandon &&
|
|
add unrelated &&
|
|
git write-tree
|
|
)
|
|
'
|
|
|
|
test_expect_success "simultaneous gc ($title)" '
|
|
git gc --prune=12.hours.ago
|
|
'
|
|
|
|
# tree should have been refreshed by write-tree
|
|
test_expect_success "finish writing out commit ($title)" '
|
|
commit=$(echo foo | git commit-tree -p HEAD $tree) &&
|
|
git update-ref HEAD $commit
|
|
'
|
|
done
|
|
|
|
test_expect_success 'do not complain about existing broken links (commit)' '
|
|
cat >broken-commit <<-EOF &&
|
|
tree $(test_oid 001)
|
|
parent $(test_oid 002)
|
|
author whatever <whatever@example.com> 1234 -0000
|
|
committer whatever <whatever@example.com> 1234 -0000
|
|
|
|
some message
|
|
EOF
|
|
commit=$(git hash-object -t commit -w broken-commit) &&
|
|
git gc -q 2>stderr &&
|
|
verbose git cat-file -e $commit &&
|
|
test_must_be_empty stderr
|
|
'
|
|
|
|
test_expect_success 'do not complain about existing broken links (tree)' '
|
|
cat >broken-tree <<-EOF &&
|
|
100644 blob $(test_oid 003) foo
|
|
EOF
|
|
tree=$(git mktree --missing <broken-tree) &&
|
|
git gc -q 2>stderr &&
|
|
git cat-file -e $tree &&
|
|
test_must_be_empty stderr
|
|
'
|
|
|
|
test_expect_success 'do not complain about existing broken links (tag)' '
|
|
cat >broken-tag <<-EOF &&
|
|
object $(test_oid 004)
|
|
type commit
|
|
tag broken
|
|
tagger whatever <whatever@example.com> 1234 -0000
|
|
|
|
this is a broken tag
|
|
EOF
|
|
tag=$(git hash-object -t tag -w broken-tag) &&
|
|
git gc -q 2>stderr &&
|
|
git cat-file -e $tag &&
|
|
test_must_be_empty stderr
|
|
'
|
|
|
|
test_done
|