kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

fetch, remote: retain old OIDs when pruning refs 

get_stale_heads() records the current value of each stale local ref in its
new_oid member. The pruning paths discard that value and request
unconditional deletion, so reference-transaction hooks receive a null old
OID.

Pass the recorded values into the deletion transactions. If a ref changes
after the stale scan, reject that deletion and preserve the new value.
Non-atomic pruning uses refs_delete_refs(), whose partial-failure mode still
deletes unaffected stale refs. An atomic fetch remains all-or-nothing.

Reuse values collected while finding stale refs, avoiding additional ref
reads. Avoid reporting deletion status when pruning encounters a rejected
update.

Signed-off-by: Maciej Ciemborowicz <maciej.ciemborowicz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Maciej Ciemborowicz 2026-09-22 14:26:09 +02:00 committed by Junio C Hamano
parent 4083022021
commit 817a49badd
3 changed files with 122 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
builtin/fetch.c
View File

@ -1471,28 +1471,36 @@ static int prune_refs(struct display_state *display_state,
struct ref *ref, *stale_refs = get_stale_heads(rs, ref_map);
struct strbuf err = STRBUF_INIT;
struct string_list refnames = STRING_LIST_INIT_NODUP;

for (ref = stale_refs; ref; ref = ref->next)
string_list_append(&refnames, ref->name);
struct oid_array old_oids = OID_ARRAY_INIT;

if (!dry_run) {
if (transaction) {
for (ref = stale_refs; ref; ref = ref->next) {
result = ref_transaction_delete(transaction, ref->name, NULL,
NULL, 0, "fetch: prune", &err);
result = ref_transaction_delete(transaction, ref->name,
&ref->new_oid, NULL, 0,
"fetch: prune", &err);
if (result)
goto cleanup;
}
} else {
for (ref = stale_refs; ref; ref = ref->next) {
string_list_append(&refnames, ref->name);
oid_array_append(&old_oids, &ref->new_oid);
}
result = refs_delete_refs(get_main_ref_store(the_repository),
"fetch: prune", &refnames,
NULL, 0);
&old_oids, 0);
}
if (result)
goto cleanup;
}

if (verbosity >= 0) {
int summary_width = transport_summary_width(stale_refs);

if (!refnames.nr)
for (ref = stale_refs; ref; ref = ref->next)
string_list_append(&refnames, ref->name);
for (ref = stale_refs; ref; ref = ref->next) {
display_ref_update(display_state, '-', _("[deleted]"), NULL,
_("(none)"), ref->name,
@ -1506,6 +1514,7 @@ static int prune_refs(struct display_state *display_state,

cleanup:
string_list_clear(&refnames, 0);
oid_array_clear(&old_oids);
strbuf_release(&err);
free_refs(stale_refs);
return result;

34
builtin/remote.c
View File

@ -17,6 +17,7 @@
#include "refs.h"
#include "refspec.h"
#include "odb.h"
#include "oid-array.h"
#include "strvec.h"
#include "commit-reach.h"
#include "progress.h"
@ -380,6 +381,11 @@ struct ref_states {
int queried;
};

struct stale_ref {
struct object_id oid;
char name[FLEX_ARRAY];
};

#define REF_STATES_INIT { \
.new_refs = STRING_LIST_INIT_DUP, \
.skipped = STRING_LIST_INIT_DUP, \
@ -410,9 +416,13 @@ static int get_ref_states(const struct ref *remote_refs, struct ref_states *stat
}
stale_refs = get_stale_heads(&states->remote->fetch, fetch_map);
for (ref = stale_refs; ref; ref = ref->next) {
struct stale_ref *stale_ref;
struct string_list_item *item =
string_list_append(&states->stale, abbrev_branch(ref->name));
item->util = xstrdup(ref->name);

FLEX_ALLOC_STR(stale_ref, name, ref->name);
oidcpy(&stale_ref->oid, &ref->new_oid);
item->util = stale_ref;
}
free_refs(stale_refs);
free_refs(fetch_map);
@ -1627,6 +1637,7 @@ static int prune_remote(const char *remote, int dry_run)
int result = 0;
struct ref_states states = REF_STATES_INIT;
struct string_list refs_to_prune = STRING_LIST_INIT_NODUP;
struct oid_array old_oids = OID_ARRAY_INIT;
struct string_list_item *item;

get_remote_ref_states(remote, &states, GET_REF_STATES);
@ -1639,17 +1650,24 @@ static int prune_remote(const char *remote, int dry_run)
printf_ln(_("Pruning %s"), remote);
printf_ln(_("URL: %s"), states.remote->url.v[0]);

for_each_string_list_item(item, &states.stale)
string_list_append(&refs_to_prune, item->util);
string_list_sort(&refs_to_prune);
for_each_string_list_item(item, &states.stale) {
struct stale_ref *stale_ref = item->util;

if (!dry_run)
string_list_append(&refs_to_prune, stale_ref->name);
oid_array_append(&old_oids, &stale_ref->oid);
}

if (!dry_run) {
result |= refs_delete_refs(get_main_ref_store(the_repository),
"remote: prune", &refs_to_prune,
NULL, 0);
&old_oids, 0);
if (result)
goto cleanup;
}

for_each_string_list_item(item, &states.stale) {
const char *refname = item->util;
struct stale_ref *stale_ref = item->util;
const char *refname = stale_ref->name;

if (dry_run)
printf_ln(_(" * [would prune] %s"),
@ -1662,7 +1680,9 @@ static int prune_remote(const char *remote, int dry_run)
refs_warn_dangling_symrefs(get_main_ref_store(the_repository),
stdout, " ", dry_run, &refs_to_prune);

cleanup:
string_list_clear(&refs_to_prune, 0);
oid_array_clear(&old_oids);
free_remote_ref_states(&states);
return result;
}

80
t/t1416-ref-transaction-hooks.sh
View File

@ -58,6 +58,86 @@ test_expect_success 'branch deletion rejects a concurrent update' '
test_cmp_rev POST refs/heads/delete-race
'

test_expect_success 'hook gets old values when pruning remote refs' '
test_when_finished "rm -rf empty.git prune" &&
git init --bare empty.git &&
git init prune &&
(
cd prune &&
git remote add origin ../empty.git &&
git commit --allow-empty -m one &&
one=$(git rev-parse HEAD) &&
git commit --allow-empty -m two &&
two=$(git rev-parse HEAD) &&
git update-ref refs/remotes/origin/remote-prune-z "$one" &&
git update-ref refs/remotes/origin/remote-prune-a "$two"
) &&
test_hook -C prune reference-transaction <<-\EOF &&
if test "$1" = committed
then
# Ignore backend-internal zero-to-zero records.
while read -r old new ref
do
case "$old" in
*[!0]*)
echo "$old $new $ref"
;;
esac
done >>actual
fi
EOF
(
cd prune &&
one=$(git rev-parse HEAD^) &&
two=$(git rev-parse HEAD) &&
git remote prune origin &&
git update-ref refs/remotes/origin/fetch-prune "$one" &&
git fetch --prune origin &&
git update-ref refs/remotes/origin/atomic-prune "$one" &&
git fetch --atomic --prune origin &&
cat >expect <<-EOF &&
$two $ZERO_OID refs/remotes/origin/remote-prune-a
$one $ZERO_OID refs/remotes/origin/remote-prune-z
$one $ZERO_OID refs/remotes/origin/fetch-prune
$one $ZERO_OID refs/remotes/origin/atomic-prune
EOF
test_cmp expect actual
)
'

test_expect_success 'remote prune rejects a concurrent update' '
test_when_finished "rm -rf race-empty.git race-prune" &&
git init --bare race-empty.git &&
git init race-prune &&
(
cd race-prune &&
git commit --allow-empty -m one &&
one=$(git rev-parse HEAD) &&
git commit --allow-empty -m two &&
two=$(git rev-parse HEAD) &&
git remote add origin ../race-empty.git &&
git update-ref refs/remotes/origin/race "$one" &&
git update-ref refs/remotes/origin/other "$one"
) &&
test_hook -C race-prune reference-transaction <<-\EOF &&
marker=$(git rev-parse --git-path prune-race-once)
if test "$1" = preparing && test ! -e "$marker"
then
>"$marker"
git update-ref refs/remotes/origin/race HEAD
fi
exit 0
EOF
(
cd race-prune &&
two=$(git rev-parse HEAD) &&
test_must_fail git remote prune origin >out 2>err &&
test_cmp_rev "$two" refs/remotes/origin/race &&
test_must_fail git rev-parse --verify refs/remotes/origin/other &&
test_grep ! "\[pruned\]" out
)
'

test_expect_success 'hook allows updating ref if successful' '
git reset --hard PRE &&
test_hook reference-transaction <<-\EOF &&