update-ref: add symref support for --stdin
A message that is not in the archive (sent off-list or not yet received): https://lore.kernel.org/r/[email protected]
v4 cover update-ref: add symref support for --stdin
From: Karthik Nayak <[email protected]>
The 'update-ref' command is used to update refs using transactions. The command allows users to also utilize a '--stdin' mode to provide a batch of sub-commands which can be processed in a transaction.
Currently, the sub-commands involve {verify, delete, create, update} and they allow users to work with regular refs in the repository. To work with symrefs, users only have the option of using 'git-symbolic-ref', which doesn't provide transaction support to the users eventhough it uses the same behind the hood.
Recently, we modified the reference backend to add symref support, following which, 'git-symbolic-ref' also uses the transaction backend. But, it doesn't expose this to the user. To allow users to work with symrefs via transaction, this series adds support for new sub-commands {symrer-verify, symref-delete, symref-create, symref-update} to the '--stdin' mode of update-ref. These complement the existing sub-commands.
The patches 1, 2, & 6 fix small issues in the reference backends. The other patches 3, 4, 5, & 7 each add one of the new sub-commands.
The series is based off master, with 'kn/ref-transaction-symref' merged in.
There was some discussion [1] also about adding old_target support to the existing update command. I think its worthwhile to do this with some tests cleanup, will follow that up as a separate series.
Changes since v3:
* Changed the position of old_target and flags in ref_transaction_delete to make it a coherent.
* Added tests for deletion of regular refs using 'symref-delete', this lead to adding a new commit to have specific errors for when a regular update contains old_target.
[1]: https://lore.kernel.org/r/CAOLa=ZQW-cCV5BP_fCvuZimfkjwAzjEiqXYRPft1Wf9kAX=_bw@mail.gmail.com
Karthik Nayak (7):
refs: create and use ref_update_expects_existing_old_ref()
refs: specify error for regular refs with old_target
update-ref: add support for 'symref-verify' command
update-ref: add support for 'symref-delete' command
update-ref: add support for 'symref-create' command
reftable: pick either 'oid' or 'target' for new updates
update-ref: add support for 'symref-update' command
Documentation/git-update-ref.txt | 25 ++ builtin/clone.c | 2 +- builtin/fetch.c | 4 +- builtin/receive-pack.c | 3 +- builtin/update-ref.c | 237 ++++++++++++++++- refs.c | 40 ++- refs.h | 6 +- refs/files-backend.c | 16 +- refs/refs-internal.h | 6 + refs/reftable-backend.c | 16 +- t/t0600-reffiles-backend.sh | 32 +++ t/t1400-update-ref.sh | 430 ++++++++++++++++++++++++++++++- t/t1416-ref-transaction-hooks.sh | 54 ++++ t/t5605-clone-local.sh | 2 +- 14 files changed, 832 insertions(+), 41 deletions(-)
Range-diff against v3:
-: ---------- > 1: cab5265c3c refs: create and use `ref_update_expects_existing_old_ref()`
-: ---------- > 2: 57b5ff46c0 refs: specify error for regular refs with `old_target`
1: ed54b0dfb9 = 3: 5710fa81bf update-ref: add support for 'symref-verify' command
2: b82b86ff40 ! 4: 5f8fc4eb6e update-ref: add support for 'symref-delete' command
@@ Commit message
within a transaction, which promises atomicity of the operation and can
be batched with other commands.
+ When no 'old_target' is provided it can also delete regular refs,
+ similar to how the 'delete' command can delete symrefs when no 'old_oid'
+ is provided.
+
Helped-by: Patrick Steinhardt <[email protected]>
Signed-off-by: Karthik Nayak <[email protected]>
@@ Documentation/git-update-ref.txt: verify::
## builtin/fetch.c ##
@@ builtin/fetch.c: static int prune_refs(struct display_state *display_state,
+ if (!dry_run) {
if (transaction) {
for (ref = stale_refs; ref; ref = ref->next) {
- result = ref_transaction_delete(transaction, ref->name, NULL, 0,
+- result = ref_transaction_delete(transaction, ref->name, NULL, 0,
- "fetch: prune", &err);
-+ NULL, "fetch: prune", &err);
++ result = ref_transaction_delete(transaction, ref->name, NULL,
++ NULL, 0, "fetch: prune", &err);
if (result)
goto cleanup;
}
@@ builtin/receive-pack.c: static const char *update(struct command *cmd, struct sh
namespaced_name,
old_oid,
- 0, "push", &err)) {
-+ 0, NULL,
++ NULL, 0,
+ "push", &err)) {
rp_error("%s", err.buf);
ret = "failed to delete";
@@ builtin/update-ref.c: static void parse_cmd_delete(struct ref_transaction *trans
if (ref_transaction_delete(transaction, refname,
have_old ? &old_oid : NULL,
- update_flags, msg, &err))
-+ update_flags, NULL, msg, &err))
++ NULL, update_flags, msg, &err))
die("%s", err.buf);
update_flags = default_flags;
@@ builtin/update-ref.c: static void parse_cmd_delete(struct ref_transaction *trans
+ die("symref-delete %s: extra input: %s", refname, next);
+
+ if (ref_transaction_delete(transaction, refname, NULL,
-+ update_flags, old_target, msg, &err))
++ old_target, update_flags, msg, &err))
+ die("%s", err.buf);
+
+ update_flags = default_flags;
@@ refs.c: int refs_delete_ref(struct ref_store *refs, const char *msg,
if (!transaction ||
ref_transaction_delete(transaction, refname, old_oid,
- flags, msg, &err) ||
-+ flags, NULL, msg, &err) ||
++ NULL, flags, msg, &err) ||
ref_transaction_commit(transaction, &err)) {
error("%s", err.buf);
ref_transaction_free(transaction);
@@ refs.c: int ref_transaction_create(struct ref_transaction *transaction,
const char *refname,
const struct object_id *old_oid,
- unsigned int flags, const char *msg,
-+ unsigned int flags,
+ const char *old_target,
++ unsigned int flags,
+ const char *msg,
struct strbuf *err)
{
@@ refs.c: int refs_delete_refs(struct ref_store *refs, const char *logmsg,
for_each_string_list_item(item, refnames) {
ret = ref_transaction_delete(transaction, item->string,
- NULL, flags, msg, &err);
-+ NULL, flags, NULL, msg, &err);
++ NULL, NULL, flags, msg, &err);
if (ret) {
warning(_("could not delete reference %s: %s"),
item->string, err.buf);
@@ refs.h: int ref_transaction_create(struct ref_transaction *transaction,
const char *refname,
const struct object_id *old_oid,
- unsigned int flags, const char *msg,
-+ unsigned int flags,
+ const char *old_target,
++ unsigned int flags,
+ const char *msg,
struct strbuf *err);
@@ t/t1400-update-ref.sh: do
+ grep "fatal: symref-delete: missing <ref>" err
+ '
+
++ test_expect_success "stdin $type symref-delete fails deleting regular ref" '
++ test_when_finished "git update-ref -d refs/heads/regularref" &&
++ git update-ref refs/heads/regularref $a &&
++ format_command $type "symref-delete refs/heads/regularref" "$a" >stdin &&
++ test_must_fail git update-ref --stdin $type --no-deref <stdin 2>err &&
++ grep "fatal: cannot update regular ref: ${SQ}refs/heads/regularref${SQ}: symref target ${SQ}$a${SQ} set" err
++ '
++
+ test_expect_success "stdin $type symref-delete fails with too many arguments" '
+ format_command $type "symref-delete refs/heads/symref" "$a" "$a" >stdin &&
+ test_must_fail git update-ref --stdin $type --no-deref <stdin 2>err &&
@@ t/t1400-update-ref.sh: do
+ git update-ref --stdin $type --no-deref <stdin &&
+ test_must_fail git symbolic-ref -d refs/heads/symref2
+ '
++
++ test_expect_success "stdin $type symref-delete fails deleting regular ref without target" '
++ git update-ref refs/heads/regularref $a &&
++ format_command $type "symref-delete refs/heads/regularref" >stdin &&
++ git update-ref --stdin $type --no-deref <stdin
++ '
+
done3: ae127f7d52 ! 5: 1542cfb806 update-ref: add support for 'symref-create' command
@@ t/t0600-reffiles-backend.sh: test_expect_success POSIXPERM 'git reflog expire ho
## t/t1400-update-ref.sh ##
@@ t/t1400-update-ref.sh: do
- test_must_fail git symbolic-ref -d refs/heads/symref2
+ git update-ref --stdin $type --no-deref <stdin
'
+ test_expect_success "stdin $type symref-create fails with too many arguments" '
4: 8889dcbf40 = 6: ec5380743d reftable: pick either 'oid' or 'target' for new updates 5: 19d85d56c4 ! 7: f8d91f7fc9 update-ref: add support for 'symref-update' command
@@ Commit message
we don't use a (ref | oid) prefix for the old_value, then there is ambiguity around if the value provided should be treated as an oid or a reference. This is more so the reason, because we allow anything
- committish to be provided as an oid.
+ committish to be provided as an oid. While 'symref-verify' and
+ 'symref-delete' also take in <old-target> we do not have this
+ divergence there as those commands only work with symrefs. Whereas
+ 'symref-update' also works with regular refs and allows users to convert
+ regular refs to symrefs.
The command allows users to perform symbolic ref updates within a transaction. This provides atomicity and allows users to perform a set
Signature · 1 line
2.43.GIT
Quoted 30 lines · Karthik Nayak
From: Karthik Nayak <[email protected]>
The 'update-ref' command is used to update refs using transactions. The command allows users to also utilize a '--stdin' mode to provide a batch of sub-commands which can be processed in a transaction.
Currently, the sub-commands involve {verify, delete, create, update} and they allow users to work with regular refs in the repository. To work with symrefs, users only have the option of using 'git-symbolic-ref', which doesn't provide transaction support to the users eventhough it uses the same behind the hood.
Recently, we modified the reference backend to add symref support, following which, 'git-symbolic-ref' also uses the transaction backend. But, it doesn't expose this to the user. To allow users to work with symrefs via transaction, this series adds support for new sub-commands {symrer-verify, symref-delete, symref-create, symref-update} to the '--stdin' mode of update-ref. These complement the existing sub-commands.
The patches 1, 2, & 6 fix small issues in the reference backends. The other patches 3, 4, 5, & 7 each add one of the new sub-commands.
The series is based off master, with 'kn/ref-transaction-symref' merged in.
There was some discussion [1] also about adding
old_targetsupport to the existingupdatecommand. I think its worthwhile to do this with some tests cleanup, will follow that up as a separate series.
Quoted 9 lines
Changes since v3:
* Changed the position ofold_targetandflagsinref_transaction_deleteto make it a coherent.
* Added tests for deletion of regular refs using 'symref-delete', this lead to adding a new commit to have specific errors for when a regular update containsold_target.[1]: https://lore.kernel.org/r/CAOLa=ZQW-cCV5BP_fCvuZimfkjwAzjEiqXYRPft1Wf9kAX=_bw@mail.gmail.com
Somehow I added the wrong link in the reply-to and this has come out as a thread of its own. This is a follow up of v3:
https://lore.kernel.org/all/[email protected]/#t
[snip]
Quoted 212 lines · Karthik Nayak
From: Karthik Nayak <[email protected]>
The 'update-ref' command is used to update refs using transactions. The command allows users to also utilize a '--stdin' mode to provide a batch of sub-commands which can be processed in a transaction.
Currently, the sub-commands involve {verify, delete, create, update} and they allow users to work with regular refs in the repository. To work with symrefs, users only have the option of using 'git-symbolic-ref', which doesn't provide transaction support to the users eventhough it uses the same behind the hood.
Recently, we modified the reference backend to add symref support, following which, 'git-symbolic-ref' also uses the transaction backend. But, it doesn't expose this to the user. To allow users to work with symrefs via transaction, this series adds support for new sub-commands {symrer-verify, symref-delete, symref-create, symref-update} to the '--stdin' mode of update-ref. These complement the existing sub-commands.
The patches 1, 2, & 6 fix small issues in the reference backends. The other patches 3, 4, 5, & 7 each add one of the new sub-commands.
The series is based off master, with 'kn/ref-transaction-symref' merged in.
There was some discussion [1] also about adding
old_targetsupport to the existingupdatecommand. I think its worthwhile to do this with some tests cleanup, will follow that up as a separate series.Changes since v3:
* Changed the position ofold_targetandflagsinref_transaction_deleteto make it a coherent.
* Added tests for deletion of regular refs using 'symref-delete', this lead to adding a new commit to have specific errors for when a regular update containsold_target.[1]: https://lore.kernel.org/r/CAOLa=ZQW-cCV5BP_fCvuZimfkjwAzjEiqXYRPft1Wf9kAX=_bw@mail.gmail.com
Karthik Nayak (7):
refs: create and useref_update_expects_existing_old_ref()
refs: specify error for regular refs withold_target
update-ref: add support for 'symref-verify' command
update-ref: add support for 'symref-delete' command
update-ref: add support for 'symref-create' command
reftable: pick either 'oid' or 'target' for new updates
update-ref: add support for 'symref-update' commandDocumentation/git-update-ref.txt | 25 ++ builtin/clone.c | 2 +- builtin/fetch.c | 4 +- builtin/receive-pack.c | 3 +- builtin/update-ref.c | 237 ++++++++++++++++- refs.c | 40 ++- refs.h | 6 +- refs/files-backend.c | 16 +- refs/refs-internal.h | 6 + refs/reftable-backend.c | 16 +- t/t0600-reffiles-backend.sh | 32 +++ t/t1400-update-ref.sh | 430 ++++++++++++++++++++++++++++++- t/t1416-ref-transaction-hooks.sh | 54 ++++ t/t5605-clone-local.sh | 2 +- 14 files changed, 832 insertions(+), 41 deletions(-)Range-diff against v3:
-: ---------- > 1: cab5265c3c refs: create and use `ref_update_expects_existing_old_ref()` -: ---------- > 2: 57b5ff46c0 refs: specify error for regular refs with `old_target` 1: ed54b0dfb9 = 3: 5710fa81bf update-ref: add support for 'symref-verify' command 2: b82b86ff40 ! 4: 5f8fc4eb6e update-ref: add support for 'symref-delete' command @@ Commit message within a transaction, which promises atomicity of the operation and can be batched with other commands. + When no 'old_target' is provided it can also delete regular refs, + similar to how the 'delete' command can delete symrefs when no 'old_oid' + is provided. + Helped-by: Patrick Steinhardt <[email protected]> Signed-off-by: Karthik Nayak <[email protected]> @@ Documentation/git-update-ref.txt: verify:: ## builtin/fetch.c ## @@ builtin/fetch.c: static int prune_refs(struct display_state *display_state, + if (!dry_run) { if (transaction) { for (ref = stale_refs; ref; ref = ref->next) { - result = ref_transaction_delete(transaction, ref->name, NULL, 0, +- result = ref_transaction_delete(transaction, ref->name, NULL, 0, - "fetch: prune", &err); -+ NULL, "fetch: prune", &err); ++ result = ref_transaction_delete(transaction, ref->name, NULL, ++ NULL, 0, "fetch: prune", &err); if (result) goto cleanup; } @@ builtin/receive-pack.c: static const char *update(struct command *cmd, struct sh namespaced_name, old_oid, - 0, "push", &err)) { -+ 0, NULL, ++ NULL, 0, + "push", &err)) { rp_error("%s", err.buf); ret = "failed to delete"; @@ builtin/update-ref.c: static void parse_cmd_delete(struct ref_transaction *trans if (ref_transaction_delete(transaction, refname, have_old ? &old_oid : NULL, - update_flags, msg, &err)) -+ update_flags, NULL, msg, &err)) ++ NULL, update_flags, msg, &err)) die("%s", err.buf); update_flags = default_flags; @@ builtin/update-ref.c: static void parse_cmd_delete(struct ref_transaction *trans + die("symref-delete %s: extra input: %s", refname, next); + + if (ref_transaction_delete(transaction, refname, NULL, -+ update_flags, old_target, msg, &err)) ++ old_target, update_flags, msg, &err)) + die("%s", err.buf); + + update_flags = default_flags; @@ refs.c: int refs_delete_ref(struct ref_store *refs, const char *msg, if (!transaction || ref_transaction_delete(transaction, refname, old_oid, - flags, msg, &err) || -+ flags, NULL, msg, &err) || ++ NULL, flags, msg, &err) || ref_transaction_commit(transaction, &err)) { error("%s", err.buf); ref_transaction_free(transaction); @@ refs.c: int ref_transaction_create(struct ref_transaction *transaction, const char *refname, const struct object_id *old_oid, - unsigned int flags, const char *msg, -+ unsigned int flags, + const char *old_target, ++ unsigned int flags, + const char *msg, struct strbuf *err) { @@ refs.c: int refs_delete_refs(struct ref_store *refs, const char *logmsg, for_each_string_list_item(item, refnames) { ret = ref_transaction_delete(transaction, item->string, - NULL, flags, msg, &err); -+ NULL, flags, NULL, msg, &err); ++ NULL, NULL, flags, msg, &err); if (ret) { warning(_("could not delete reference %s: %s"), item->string, err.buf); @@ refs.h: int ref_transaction_create(struct ref_transaction *transaction, const char *refname, const struct object_id *old_oid, - unsigned int flags, const char *msg, -+ unsigned int flags, + const char *old_target, ++ unsigned int flags, + const char *msg, struct strbuf *err); @@ t/t1400-update-ref.sh: do + grep "fatal: symref-delete: missing <ref>" err + ' + ++ test_expect_success "stdin $type symref-delete fails deleting regular ref" ' ++ test_when_finished "git update-ref -d refs/heads/regularref" && ++ git update-ref refs/heads/regularref $a && ++ format_command $type "symref-delete refs/heads/regularref" "$a" >stdin && ++ test_must_fail git update-ref --stdin $type --no-deref <stdin 2>err && ++ grep "fatal: cannot update regular ref: ${SQ}refs/heads/regularref${SQ}: symref target ${SQ}$a${SQ} set" err ++ ' ++ + test_expect_success "stdin $type symref-delete fails with too many arguments" ' + format_command $type "symref-delete refs/heads/symref" "$a" "$a" >stdin && + test_must_fail git update-ref --stdin $type --no-deref <stdin 2>err && @@ t/t1400-update-ref.sh: do + git update-ref --stdin $type --no-deref <stdin && + test_must_fail git symbolic-ref -d refs/heads/symref2 + ' ++ ++ test_expect_success "stdin $type symref-delete fails deleting regular ref without target" ' ++ git update-ref refs/heads/regularref $a && ++ format_command $type "symref-delete refs/heads/regularref" >stdin && ++ git update-ref --stdin $type --no-deref <stdin ++ ' + done3:
ae127f7d52! 5:1542cfb806update-ref: add support for 'symref-create' command
@@t/t0600-reffiles-backend.sh:test_expect_successPOSIXPERM 'git reflog expire ho##
t/t1400-update-ref.sh##
@@t/t1400-update-ref.sh: do
-test_must_failgit symbolic-ref -d refs/heads/symref2
+ git update-ref --stdin $type --no-deref <stdin
'+
test_expect_success"stdin $type symref-create fails with too many arguments" '4: 8889dcbf40 = 6: ec5380743d reftable: pick either 'oid' or 'target' for new updates 5: 19d85d56c4 ! 7: f8d91f7fc9 update-ref: add support for 'symref-update' command@@ Commit message
we don't use a(ref | oid)prefix for theold_value, then there is ambiguity around if the value provided should be treated as an oid or a reference. This is more so the reason, because we allow anything
- committish to be provided as an oid.
+ committish to be provided as an oid. While 'symref-verify' and
+ 'symref-delete' also take in<old-target>we do not have this
+ divergence there as those commands only work with symrefs. Whereas
+ 'symref-update' also works with regular refs and allows users to convert
+ regular refs to symrefs.
Quoted 4 lines
The command allows users to perform symbolic ref updates within a transaction. This provides atomicity and allows users to perform a set
--
2.43.GIT
I also noticed that the range-diff seems a bit weird. I used
git format-patch -v 4 --cover-letter --range-diff=symref-cmd-v3 @~7..@
to generate the patch series, but seems like when doing this it internally computes the merge-base, which happens to be the first commit in this series, skewing the range-diff by one commit. I guess its always better to provide the commit range to --range-diff. Adding the range diff for the same, when run using
git format-patch -v 4 --cover-letter
--range-diff=6ab505f161..symref-cmd-v3 @~7..@
where 6ab505f161 is the common base for both v3 and v4, and is from merging in ps/leakfixes.
Range-diff against v3:
1: cab5265c3c = 1: cab5265c3c refs: create and use ref_update_expects_existing_old_ref()
-: ---------- > 2: 57b5ff46c0 refs: specify error for regular refs with old_target
2: ed54b0dfb9 = 3: 5710fa81bf update-ref: add support for 'symref-verify' command
3: b82b86ff40 ! 4: 5f8fc4eb6e update-ref: add support for 'symref-delete' command
@@ Commit message
within a transaction, which promises atomicity of the operation and can be batched with other commands.
+ When no 'old_target' is provided it can also delete regular refs,
+ similar to how the 'delete' command can delete symrefs when
no 'old_oid'
+ is provided.
+
@@ Documentation/git-update-ref.txt: verify::
## builtin/fetch.c ##
@@ builtin/fetch.c: static int prune_refs(struct display_state*display_state,
+ if (!dry_run) {
if (transaction) {
for (ref = stale_refs; ref; ref = ref->next) {
- result = ref_transaction_delete(transaction, ref->name, NULL, 0,
+- result = ref_transaction_delete(transaction, ref->name, NULL, 0,
- "fetch: prune", &err);
-+ NULL, "fetch: prune", &err);
++ result = ref_transaction_delete(transaction, ref->name, NULL,
++ NULL, 0, "fetch: prune", &err);
if (result)
goto cleanup;
}
@@ builtin/receive-pack.c: static const char *update(struct
command *cmd, struct sh
namespaced_name,
old_oid,
- 0, "push", &err)) {
-+ 0, NULL,
++ NULL, 0,
+ "push", &err)) {
rp_error("%s", err.buf);
ret = "failed to delete";
@@ builtin/update-ref.c: static void parse_cmd_delete(struct
ref_transaction *trans
if (ref_transaction_delete(transaction, refname,
have_old ? &old_oid : NULL,
- update_flags, msg, &err))
-+ update_flags, NULL, msg, &err))
++ NULL, update_flags, msg, &err))
die("%s", err.buf);
update_flags = default_flags;
@@ builtin/update-ref.c: static void parse_cmd_delete(struct
ref_transaction *trans
+ die("symref-delete %s: extra input: %s", refname, next);
+
+ if (ref_transaction_delete(transaction, refname, NULL,
-+ update_flags, old_target, msg, &err))
++ old_target, update_flags, msg, &err))
+ die("%s", err.buf);
+
+ update_flags = default_flags;
@@ refs.c: int refs_delete_ref(struct ref_store *refs, const char *msg,
if (!transaction ||
ref_transaction_delete(transaction, refname, old_oid,
- flags, msg, &err) ||
-+ flags, NULL, msg, &err) ||
++ NULL, flags, msg, &err) ||
ref_transaction_commit(transaction, &err)) {
error("%s", err.buf);
ref_transaction_free(transaction);
@@ refs.c: int ref_transaction_create(struct ref_transaction *transaction,
const char *refname,
const struct object_id *old_oid,
- unsigned int flags, const char *msg,
-+ unsigned int flags,
+ const char *old_target,
++ unsigned int flags,
+ const char *msg,
struct strbuf *err)
{
@@ refs.c: int refs_delete_refs(struct ref_store *refs, const char *logmsg,
for_each_string_list_item(item, refnames) {
ret = ref_transaction_delete(transaction, item->string,
- NULL, flags, msg, &err);
-+ NULL, flags, NULL, msg, &err);
++ NULL, NULL, flags, msg, &err);
if (ret) {
warning(_("could not delete reference %s: %s"),
item->string, err.buf);
@@ refs.h: int ref_transaction_create(struct ref_transaction *transaction,
const char *refname,
const struct object_id *old_oid,
- unsigned int flags, const char *msg,
-+ unsigned int flags,
+ const char *old_target,
++ unsigned int flags,
+ const char *msg,
struct strbuf *err);
@@ t/t1400-update-ref.sh: do
+ grep "fatal: symref-delete: missing <ref>" err
+ '
+
++ test_expect_success "stdin $type symref-delete fails deleting
regular ref" '
++ test_when_finished "git update-ref -d refs/heads/regularref" &&
++ git update-ref refs/heads/regularref $a &&
++ format_command $type "symref-delete refs/heads/regularref""$a" >stdin &&
++ test_must_fail git update-ref --stdin $type --no-deref <stdin 2>err &&
++ grep "fatal: cannot update regular ref:
${SQ}refs/heads/regularref${SQ}: symref target ${SQ}$a${SQ} set" err
++ '
++
+ test_expect_success "stdin $type symref-delete fails with too
many arguments" '
+ format_command $type "symref-delete refs/heads/symref" "$a"
"$a" >stdin &&
+ test_must_fail git update-ref --stdin $type --no-deref <stdin 2>err &&
@@ t/t1400-update-ref.sh: do
+ git update-ref --stdin $type --no-deref <stdin &&
+ test_must_fail git symbolic-ref -d refs/heads/symref2
+ '
++
++ test_expect_success "stdin $type symref-delete fails deleting
regular ref without target" '
++ git update-ref refs/heads/regularref $a &&
++ format_command $type "symref-delete refs/heads/regularref" >stdin &&
++ git update-ref --stdin $type --no-deref <stdin
++ '
+
done4: ae127f7d52 ! 5: 1542cfb806 update-ref: add support for 'symref-create' command
@@ t/t0600-reffiles-backend.sh: test_expect_success POSIXPERM 'git
reflog expire ho
## t/t1400-update-ref.sh ##
@@ t/t1400-update-ref.sh: do
- test_must_fail git symbolic-ref -d refs/heads/symref2
+ git update-ref --stdin $type --no-deref <stdin
'
+ test_expect_success "stdin $type symref-create fails with too
many arguments" '
5: 8889dcbf40 = 6: ec5380743d reftable: pick either 'oid' or 'target' for new updates
6: 19d85d56c4 ! 7: f8d91f7fc9 update-ref: add support for 'symref-update' command
@@ Commit message
we don't use a (ref | oid) prefix for the old_value, then there is ambiguity around if the value provided should be treated as an oid or a reference. This is more so the reason, because we allow anything
- committish to be provided as an oid.
+ committish to be provided as an oid. While 'symref-verify' and
+ 'symref-delete' also take in <old-target> we do not have this
+ divergence there as those commands only work with symrefs. Whereas
+ 'symref-update' also works with regular refs and allows users
to convert
+ regular refs to symrefs.
The command allows users to perform symbolic ref updates within a transaction. This provides atomicity and allows users to perform a set
Signature · 1 line
2.43.GIT
v5 cover update-ref: add symref support for --stdin
In reply to Karthik NayakFrom: Karthik Nayak <[email protected]>
The 'update-ref' command is used to update refs using transactions. The command allows users to also utilize a '--stdin' mode to provide a batch of sub-commands which can be processed in a transaction.
Currently, the sub-commands involve {verify, delete, create, update} and they allow users to work with regular refs in the repository. To work with symrefs, users only have the option of using 'git-symbolic-ref', which doesn't provide transaction support to the users eventhough it uses the same behind the hood.
Recently, we modified the reference backend to add symref support, following which, 'git-symbolic-ref' also uses the transaction backend. But, it doesn't expose this to the user. To allow users to work with symrefs via transaction, this series adds support for new sub-commands {symrer-verify, symref-delete, symref-create, symref-update} to the '--stdin' mode of update-ref. These complement the existing sub-commands.
The patches 1, 2, & 6 fix small issues in the reference backends. The other patches 3, 4, 5, & 7 each add one of the new sub-commands.
The series is based off master, with 'kn/ref-transaction-symref' merged in.
There was some discussion [1] also about adding old_target support to the existing update command. I think its worthwhile to do this with some tests cleanup, will follow that up as a separate series.
Changes since v4:
* Modified the commit message for the second patch and also the error to be less technical and more user friendly.
* Renamed an incorrectly named test.
Version 1-3 can be found here:
https://lore.kernel.org/all/[email protected]/
[1]: https://lore.kernel.org/r/CAOLa=ZQW-cCV5BP_fCvuZimfkjwAzjEiqXYRPft1Wf9kAX=_bw@mail.gmail.com
Karthik Nayak (7):
refs: create and use ref_update_expects_existing_old_ref()
refs: specify error for regular refs with old_target
update-ref: add support for 'symref-verify' command
update-ref: add support for 'symref-delete' command
update-ref: add support for 'symref-create' command
reftable: pick either 'oid' or 'target' for new updates
update-ref: add support for 'symref-update' command
Documentation/git-update-ref.txt | 25 ++ builtin/clone.c | 2 +- builtin/fetch.c | 4 +- builtin/receive-pack.c | 3 +- builtin/update-ref.c | 237 ++++++++++++++++- refs.c | 40 ++- refs.h | 6 +- refs/files-backend.c | 17 +- refs/refs-internal.h | 6 + refs/reftable-backend.c | 17 +- t/t0600-reffiles-backend.sh | 32 +++ t/t1400-update-ref.sh | 430 ++++++++++++++++++++++++++++++- t/t1416-ref-transaction-hooks.sh | 54 ++++ t/t5605-clone-local.sh | 2 +- 14 files changed, 834 insertions(+), 41 deletions(-)
Range-diff against v4:
1: cab5265c3c = 1: cab5265c3c refs: create and use `ref_update_expects_existing_old_ref()`
2: 57b5ff46c0 ! 2: 94077e69cc refs: specify error for regular refs with `old_target`
@@ Metadata
## Commit message ##
refs: specify error for regular refs with `old_target`
- When a regular reference update contains `old_target` set, we call the
- `ref_update_check_old_target` function to check the referent value. But
- for regular refs we know that the referent value is not set and this
- simply raises a generic error which says nothing about this being a
- regular ref. Instead let's raise a more specific error when a regular
- ref update contains `old_target`.
+ When a reference update tries to update a symref, but the ref in
+ question is actually a regular ref, we raise an error. However the error
+ raised in this situation is:
+
+ verifying symref target: '<ref>': reference is missing but expected <old-target>
+
+ which is very generic and doesn't indicate the mismatch of types. Let's
+ make this error more specific:
+
+ cannot lock ref '<ref>': expected symref with target '<old-target>': but is a regular ref
+
+ so that users have a clearer understanding.
Signed-off-by: Karthik Nayak <[email protected]>
@@ refs/files-backend.c: static int lock_ref_for_update(struct files_ref_store *ref
- ret = TRANSACTION_GENERIC_ERROR;
- goto out;
- }
-+ strbuf_addf(err, _("cannot update regular ref: '%s': "
-+ "symref target '%s' set"),
++ strbuf_addf(err, _("cannot lock ref '%s': "
++ "expected symref with target '%s': "
++ "but is a regular ref"),
+ ref_update_original_update_refname(update),
+ update->old_target);
+ ret = TRANSACTION_GENERIC_ERROR;
@@ refs/reftable-backend.c: static int reftable_be_transaction_prepare(struct ref_s
*/
if (u->old_target) {
+ if (!(u->type & REF_ISSYMREF)) {
-+ strbuf_addf(err, _("cannot update regular ref: '%s': "
-+ "symref target '%s' set"),
++ strbuf_addf(err, _("cannot lock ref '%s': "
++ "expected symref with target '%s': "
++ "but is a regular ref"),
+ ref_update_original_update_refname(u),
+ u->old_target);
+ ret = -1;
3: 5710fa81bf = 3: 153d8cce75 update-ref: add support for 'symref-verify' command
4: 5f8fc4eb6e ! 4: 07382bfa09 update-ref: add support for 'symref-delete' command
@@ t/t1400-update-ref.sh: do
+ git update-ref refs/heads/regularref $a &&
+ format_command $type "symref-delete refs/heads/regularref" "$a" >stdin &&
+ test_must_fail git update-ref --stdin $type --no-deref <stdin 2>err &&
-+ grep "fatal: cannot update regular ref: ${SQ}refs/heads/regularref${SQ}: symref target ${SQ}$a${SQ} set" err
++ grep "fatal: cannot lock ref ${SQ}refs/heads/regularref${SQ}: expected symref with target ${SQ}$a${SQ}: but is a regular ref" err
+ '
+
+ test_expect_success "stdin $type symref-delete fails with too many arguments" '
@@ t/t1400-update-ref.sh: do
+ test_must_fail git symbolic-ref -d refs/heads/symref2
+ '
+
-+ test_expect_success "stdin $type symref-delete fails deleting regular ref without target" '
++ test_expect_success "stdin $type symref-delete deletes regular ref without target" '
+ git update-ref refs/heads/regularref $a &&
+ format_command $type "symref-delete refs/heads/regularref" >stdin &&
+ git update-ref --stdin $type --no-deref <stdin
5: 1542cfb806 = 5: d5f92f610d update-ref: add support for 'symref-create' command
6: ec5380743d = 6: 117b9e49cd reftable: pick either 'oid' or 'target' for new updates
7: f8d91f7fc9 = 7: cc140fedbd update-ref: add support for 'symref-update' commandSignature · 1 line
2.43.GIT
PATCH v5 1/7 refs: create and use `ref_update_expects_existing_old_ref()`
From: Karthik Nayak <[email protected]>
The files and reftable backend, need to check if a ref must exist, so that the required validation can be done. A ref must exist only when the old_oid value of the update has been explicitly set and it is not the null_oid value.
Since we also support symrefs now, we need to ensure that even when old_target is set a ref must exist. While this was missed when we added symref support in transactions, there are no active users of this path. As we introduce the 'symref-verify' command in the upcoming commits, it is important to fix this.
So let's export this to a function called ref_update_expects_existing_old_ref() and expose it internally via 'refs-internal.h'.
--- refs.c | 6 ++++++ refs/files-backend.c | 3 +-- refs/refs-internal.h | 6 ++++++ refs/reftable-backend.c | 2 +- 4 files changed, 14 insertions(+), 3 deletions(-)
refs.c +6 -0
@@ -2679,3 +2679,9 @@ int ref_update_check_old_target(const char *referent, struct ref_update *update, referent, update->old_target);return -1 ; } + +int ref_update_expects_existing_old_ref (struct ref_update *update) +{ +return (update->flags &REF_HAVE_OLD ) && + (!is_null_oid (&update->old_oid) || update->old_target); +}
refs/files-backend.c +1 -2
@@ -2412,8 +2412,7 @@ static int lock_ref_for_update(struct files_ref_store *refs, struct strbuf *err) {struct strbuf referent =STRBUF_INIT ; -int mustexist = (update->flags &REF_HAVE_OLD ) && - !is_null_oid (&update->old_oid); +int mustexist =ref_update_expects_existing_old_ref (update);int ret =0 ;struct ref_lock *lock;
refs/refs-internal.h +6 -0
@@ -765,4 +765,10 @@ int ref_update_has_null_new_value(struct ref_update *update);int ref_update_check_old_target (const char *referent,struct ref_update *update,struct strbuf *err); +/* +* Check if the ref must exist, this means that the old_oid or +* old_target is non NULL. +*/ +int ref_update_expects_existing_old_ref (struct ref_update *update); +#endif /* REFS_REFS_INTERNAL_H */
refs/reftable-backend.c +1 -1
@@ -824,7 +824,7 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store, ¤t_oid, &referent, &u->type);if (ret <0 ) goto done; -if (ret >0 && (!(u->flags &REF_HAVE_OLD ) ||is_null_oid (&u->old_oid))) { +if (ret >0 && !ref_update_expects_existing_old_ref (u)) {/* * The reference does not exist, and we either have no * old object ID or expect the reference to not exist.
Signature · 1 line
2.43.GIT
PATCH v5 2/7 refs: specify error for regular refs with `old_target`
In reply to Karthik NayakFrom: Karthik Nayak <[email protected]>
When a reference update tries to update a symref, but the ref in question is actually a regular ref, we raise an error. However the error raised in this situation is:
verifying symref target: '<ref>': reference is missing but expected <old-target>
which is very generic and doesn't indicate the mismatch of types. Let's make this error more specific:
cannot lock ref '<ref>': expected symref with target '<old-target>': but is a regular ref
so that users have a clearer understanding.
--- refs/files-backend.c | 14 ++++++++------ refs/reftable-backend.c | 10 ++++++++++ 2 files changed, 18 insertions(+), 6 deletions(-)
refs/files-backend.c +8 -6
@@ -2491,14 +2491,16 @@ static int lock_ref_for_update(struct files_ref_store *refs,/* * Even if the ref is a regular ref, if `old_target` is set, we -* check the referent value. Ideally `old_target` should only -* be set for symrefs, but we're strict about its usage. +* fail with an error. */ if (update->old_target) { -if (ref_update_check_old_target (referent.buf, update, err)) { - ret =TRANSACTION_GENERIC_ERROR ; - goto out; - } +strbuf_addf (err,_ ("cannot lock ref '%s': " +"expected symref with target '%s': " +"but is a regular ref" ), +ref_update_original_update_refname (update), + update->old_target); + ret =TRANSACTION_GENERIC_ERROR ; + goto out; }else if (check_old_oid (update, &lock->old_oid, err)) { ret =TRANSACTION_GENERIC_ERROR ; goto out;
refs/reftable-backend.c +10 -0
@@ -928,6 +928,16 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,* backend returns, which keeps our tests happy. */ if (u->old_target) { +if (!(u->type &REF_ISSYMREF )) { +strbuf_addf (err,_ ("cannot lock ref '%s': " +"expected symref with target '%s': " +"but is a regular ref" ), +ref_update_original_update_refname (u), + u->old_target); + ret =-1 ; + goto done; + } +if (ref_update_check_old_target (referent.buf, u, err)) { ret =-1 ; goto done;
Signature · 1 line
2.43.GIT
Re: [PATCH v5 2/7] refs: specify error for regular refs with `old_target`
Quoted 14 lines · Karthik Nayak
refs/files-backend.c +1
-3@@ -2491,14 +2491,16 @@ static int lock_ref_for_update(struct files_ref_store *refs,/* * Even if the ref is a regular ref, if `old_target` is set, we -* check the referent value. Ideally `old_target` should only -* be set for symrefs, but we're strict about its usage. +* fail with an error. */ if (update->old_target) { -if (ref_update_check_old_target (referent.buf, update, err)) {
refs/files-backend.c static int lock_ref_for_update(struct files_ref_store *refs, · line 2503
Quoted 10 lines
refs/files-backend.c +7
-3- ret =TRANSACTION_GENERIC_ERROR ; - goto out; - } +strbuf_addf (err,_ ("cannot lock ref '%s': " +"expected symref with target '%s': " +"but is a regular ref" ), +ref_update_original_update_refname (update), + update->old_target); + ret =TRANSACTION_GENERIC_ERROR ; + goto out;
Shouldn't the second colon be a comma? "expected symref, but is a regular ref" reads way more natural to me than "expected symref: but is a regular ref".
Other than that this series looks good to me now, thanks!
Patrick
Re: [PATCH v5 2/7] refs: specify error for regular refs with `old_target`
Quoted 21 lines · Patrick Steinhardt
Quoted 20 lines · Karthik Nayak
refs/files-backend.c +4
-6@@ -2491,14 +2491,16 @@ static int lock_ref_for_update(struct files_ref_store *refs,/* * Even if the ref is a regular ref, if `old_target` is set, we -* check the referent value. Ideally `old_target` should only -* be set for symrefs, but we're strict about its usage. +* fail with an error. */ if (update->old_target) { -if (ref_update_check_old_target (referent.buf, update, err)) { - ret =TRANSACTION_GENERIC_ERROR ; - goto out; - } + strbuf_addf(err, _("cannot lock ref '%s': " + "expected symref with target '%s': " + "but is a regular ref"),
Quoted 9 lines
refs/files-backend.c static int lock_ref_for_update(struct files_ref_store *refs, · line 2503
Quoted 4 lines
refs/files-backend.c +4
-0+ref_update_original_update_refname (update), + update->old_target); + ret =TRANSACTION_GENERIC_ERROR ; + goto out;Shouldn't the second colon be a comma? "expected symref, but is a regular ref" reads way more natural to me than "expected symref: but is a regular ref".
It makes sense the way you put it, but we also print the 'target', so it is something like "cannot lock ref 'refs/heads/branch1': expected symref with target 'refs/heads/master': but is a regular ref". I felt here the colon divides the error into three segments
1. States that we couldn't lock the file
2. States that we were expecting a symref with a particular target
3. States that the ref in question is actually a regular ref
Having said that, I'm not too bullish on this and happy to change it :)
Quoted 4 lines
Other than that this series looks good to me now, thanks!
Patrick
Thanks for all the reviews. Since this is the only change, I'm inclined to leave it as is.
Karthik
PATCH v5 3/7 update-ref: add support for 'symref-verify' command
In reply to Karthik NayakFrom: Karthik Nayak <[email protected]>
The 'symref-verify' command allows users to verify if a provided <ref> contains the provided <old-target> without changing the <ref>. If <old-target> is not provided, the command will verify that the <ref> doesn't exist.
The command allows users to verify symbolic refs within a transaction, and this means users can perform a set of changes in a transaction only when the verification holds good.
Since we're checking for symbolic refs, this command will only work with the 'no-deref' mode. This is because any dereferenced symbolic ref will point to an object and not a ref and the regular 'verify' command can be used in such situations.
Add required tests for symref support in 'verify'. Since we're here, also add reflog checks for the pre-existing 'verify' tests, there is no divergence from behavior, but we never tested to ensure that reflog wasn't affected by the 'verify' command.
--- Documentation/git-update-ref.txt | 7 +++ builtin/update-ref.c | 80 +++++++++++++++++++++++---- refs.c | 11 +++- refs.h | 1 + t/t1400-update-ref.sh | 94 +++++++++++++++++++++++++++++++- t/t1416-ref-transaction-hooks.sh | 30 ++++++++++ 6 files changed, 208 insertions(+), 15 deletions(-)
Documentation/git-update-ref.txt +7 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-verify SP <ref> [SP <old-target>] LF option SP <opt> LF start LF prepare LF
@@ -86,6 +87,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-verify SP <ref> [NUL <old-target>] NUL option SP <opt> NUL start NUL prepare NUL
@@ -117,6 +119,11 @@ verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist. +symref-verify:: + Verify symbolic <ref> against <old-target> but do not change it. + If <old-target> is missing, the ref must not exist. Can only be + used in `no-deref` mode. + option:: Modify the behavior of the next command naming a <ref>. The only valid option is `no-deref` to avoid dereferencing
builtin/update-ref.c +70 -10
102 lines not on this page · raw message
refs.c +8 -3
@@ -1297,14 +1297,19 @@ int ref_transaction_delete(struct ref_transaction *transaction,int ref_transaction_verify (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, +const char *old_target,unsigned int flags,struct strbuf *err) { -if (!old_oid) -BUG ("verify called with old_oid set to NULL" ); +if (!old_target && !old_oid) +BUG ("verify called with old_oid and old_target set to NULL" ); +if (old_oid && old_target) +BUG ("verify called with both old_oid and old_target set" ); +if (old_target && !(flags &REF_NO_DEREF )) +BUG ("verify cannot operate on symrefs with deref mode" );return ref_transaction_update (transaction, refname,NULL , old_oid, -NULL ,NULL , +NULL , old_target, flags,NULL , err); }
refs.h +1 -0
@@ -736,6 +736,7 @@ int ref_transaction_delete(struct ref_transaction *transaction,int ref_transaction_verify (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, +const char *old_target,unsigned int flags,struct strbuf *err);
t/t1400-update-ref.sh +92 -2
113 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +30 -0
@@ -157,4 +157,34 @@ test_expect_success 'hook captures git-symbolic-ref updates' ' test_cmp expect actual ' +test_expect_success 'hook gets all queued symref updates' ' + test_when_finished "rm actual" && + + git update-ref refs/heads/branch $POST_OID && + git symbolic-ref refs/heads/symref refs/heads/main && + + test_hook reference-transaction <<-\EOF && + echo "$*" >>actual + while read -r line + do + printf "%s\n" "$line" + done >>actual + EOF + + cat >expect <<-EOF && + prepared + ref:refs/heads/main $ZERO_OID refs/heads/symref + committed + ref:refs/heads/main $ZERO_OID refs/heads/symref + EOF + + git update-ref --no-deref --stdin <<-EOF && + start + symref-verify refs/heads/symref refs/heads/main + prepare + commit + EOF + test_cmp expect actual +' + test_done
Signature · 1 line
2.43.GIT
PATCH v5 4/7 update-ref: add support for 'symref-delete' command
In reply to Karthik NayakFrom: Karthik Nayak <[email protected]>
Add a new command 'symref-delete' to allow deletions of symbolic refs in a transaction via the '--stdin' mode of the 'git-update-ref' command. The 'symref-delete' command can, when given an <old-target>, delete the provided <ref> only when it points to <old-target>.
This command is only compatible with the 'no-deref' mode because we optionally want to check the 'old_target' of the ref being deleted. De-referencing a symbolic ref would provide a regular ref and we already have the 'delete' command for regular refs.
While users can also use 'git symbolic-ref -d' to delete symbolic refs, the 'symref-delete' command in 'git-update-ref' allows users to do so within a transaction, which promises atomicity of the operation and can be batched with other commands.
When no 'old_target' is provided it can also delete regular refs, similar to how the 'delete' command can delete symrefs when no 'old_oid' is provided.
--- Documentation/git-update-ref.txt | 5 +++ builtin/fetch.c | 4 +- builtin/receive-pack.c | 3 +- builtin/update-ref.c | 33 +++++++++++++++- refs.c | 14 +++++-- refs.h | 4 +- t/t1400-update-ref.sh | 68 ++++++++++++++++++++++++++++++++ t/t1416-ref-transaction-hooks.sh | 19 ++++++++- 8 files changed, 140 insertions(+), 10 deletions(-)
Documentation/git-update-ref.txt +5 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-delete SP <ref> [SP <old-target>] LF symref-verify SP <ref> [SP <old-target>] LF option SP <opt> LF start LF
@@ -87,6 +88,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-delete SP <ref> [NUL <old-target>] NUL symref-verify SP <ref> [NUL <old-target>] NUL option SP <opt> NUL start NUL
@@ -119,6 +121,9 @@ verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist. +symref-delete:: + Delete <ref> after verifying it exists with <old-target>, if given. + symref-verify:: Verify symbolic <ref> against <old-target> but do not change it. If <old-target> is missing, the ref must not exist. Can only be
builtin/fetch.c +2 -2
@@ -1386,8 +1386,8 @@ static int prune_refs(struct display_state *display_state,if (!dry_run) {if (transaction) {for (ref = stale_refs; ref; ref = ref->next) { - result =ref_transaction_delete (transaction, ref->name,NULL ,0 , -"fetch: prune" , &err); + result =ref_transaction_delete (transaction, ref->name,NULL , +NULL ,0 ,"fetch: prune" , &err);if (result) goto cleanup; }
builtin/receive-pack.c +2 -1
@@ -1576,7 +1576,8 @@ static const char *update(struct command *cmd, struct shallow_info *si)if (ref_transaction_delete (transaction, namespaced_name, old_oid, -0 ,"push" , &err)) { +NULL ,0 , +"push" , &err)) {rp_error ("%s" , err.buf); ret ="failed to delete" ; }else {
builtin/update-ref.c +32 -1
@@ -293,7 +293,7 @@ static void parse_cmd_delete(struct ref_transaction *transaction,if (ref_transaction_delete (transaction, refname, have_old ? &old_oid :NULL , - update_flags, msg, &err)) +NULL , update_flags, msg, &err))die ("%s" , err.buf); update_flags = default_flags;
@@ -301,6 +301,36 @@ static void parse_cmd_delete(struct ref_transaction *transaction,strbuf_release (&err); } + +static void parse_cmd_symref_delete (struct ref_transaction *transaction, +const char *next,const char *end) +{ +struct strbuf err =STRBUF_INIT ; +char *refname, *old_target; + +if (!(update_flags &REF_NO_DEREF )) +die ("symref-delete: cannot operate with deref mode" ); + + refname =parse_refname (&next); +if (!refname) +die ("symref-delete: missing <ref>" ); + + old_target =parse_next_refname (&next); + +if (*next != line_termination) +die ("symref-delete %s: extra input: %s" , refname, next); + +if (ref_transaction_delete (transaction, refname,NULL , + old_target, update_flags, msg, &err)) +die ("%s" , err.buf); + + update_flags = default_flags; +free (refname); +free (old_target); +strbuf_release (&err); +} + +static void parse_cmd_verify (struct ref_transaction *transaction,const char *next,const char *end) {
@@ -443,6 +473,7 @@ static const struct parse_cmd { { "create", parse_cmd_create, 2, UPDATE_REFS_OPEN }, { "delete", parse_cmd_delete, 2, UPDATE_REFS_OPEN }, { "verify", parse_cmd_verify, 2, UPDATE_REFS_OPEN }, + { "symref-delete", parse_cmd_symref_delete, 2, UPDATE_REFS_OPEN }, { "symref-verify", parse_cmd_symref_verify, 2, UPDATE_REFS_OPEN }, { "option", parse_cmd_option, 1, UPDATE_REFS_OPEN }, { "start", parse_cmd_start, 0, UPDATE_REFS_STARTED },
refs.c +10 -4
@@ -950,7 +950,7 @@ int refs_delete_ref(struct ref_store *refs, const char *msg, transaction =ref_store_transaction_begin (refs, &err);if (!transaction ||ref_transaction_delete (transaction, refname, old_oid, - flags, msg, &err) || +NULL , flags, msg, &err) ||ref_transaction_commit (transaction, &err)) {error ("%s" , err.buf);ref_transaction_free (transaction);
@@ -1283,14 +1283,20 @@ int ref_transaction_create(struct ref_transaction *transaction,int ref_transaction_delete (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, -unsigned int flags,const char *msg, +const char *old_target, +unsigned int flags, +const char *msg,struct strbuf *err) {if (old_oid &&is_null_oid (old_oid))BUG ("delete called with old_oid set to zeros" ); +if (old_oid && old_target) +BUG ("delete called with both old_oid and old_target set" ); +if (old_target && !(flags &REF_NO_DEREF )) +BUG ("delete cannot operate on symrefs with deref mode" );return ref_transaction_update (transaction, refname,null_oid (), old_oid, -NULL ,NULL , flags, +NULL , old_target, flags, msg, err); }
@@ -2599,7 +2605,7 @@ int refs_delete_refs(struct ref_store *refs, const char *logmsg,for_each_string_list_item (item, refnames) { ret =ref_transaction_delete (transaction, item->string, -NULL , flags, msg, &err); +NULL ,NULL , flags, msg, &err);if (ret) {warning (_ ("could not delete reference %s: %s" ), item->string, err.buf);
refs.h +3 -1
@@ -722,7 +722,9 @@ int ref_transaction_create(struct ref_transaction *transaction,int ref_transaction_delete (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, -unsigned int flags,const char *msg, +const char *old_target, +unsigned int flags, +const char *msg,struct strbuf *err);/*
t/t1400-update-ref.sh +68 -0
74 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +18 -1
@@ -162,6 +162,7 @@ test_expect_success 'hook gets all queued symref updates' ' git update-ref refs/heads/branch $POST_OID && git symbolic-ref refs/heads/symref refs/heads/main && + git symbolic-ref refs/heads/symrefd refs/heads/main && test_hook reference-transaction <<-\EOF && echo "$*" >>actual
@@ -171,16 +172,32 @@ test_expect_success 'hook gets all queued symref updates' ' done >>actual EOF - cat >expect <<-EOF && + # In the files backend, "delete" also triggers an additional transaction + # update on the packed-refs backend, which constitutes additional reflog + # entries. + if test_have_prereq REFFILES + then + cat >expect <<-EOF + aborted + $ZERO_OID $ZERO_OID refs/heads/symrefd + EOF + else + >expect + fi && + + cat >>expect <<-EOF && prepared ref:refs/heads/main $ZERO_OID refs/heads/symref + ref:refs/heads/main $ZERO_OID refs/heads/symrefd committed ref:refs/heads/main $ZERO_OID refs/heads/symref + ref:refs/heads/main $ZERO_OID refs/heads/symrefd EOF git update-ref --no-deref --stdin <<-EOF && start symref-verify refs/heads/symref refs/heads/main + symref-delete refs/heads/symrefd refs/heads/main prepare commit EOF
Signature · 1 line
2.43.GIT
PATCH v5 5/7 update-ref: add support for 'symref-create' command
In reply to Karthik NayakFrom: Karthik Nayak <[email protected]>
Add 'symref-create' command to the '--stdin' mode 'git-update-ref' to allow creation of symbolic refs in a transaction. The 'symref-create' command takes in a <new-target>, which the created <ref> will point to.
Also, support the 'core.prefersymlinkrefs' config, wherein if the config is set and the filesystem supports symlinks, we create the symbolic ref as a symlink. We fallback to creating a regular symref if creating the symlink is unsuccessful.
--- Documentation/git-update-ref.txt | 6 +++ builtin/clone.c | 2 +- builtin/update-ref.c | 32 +++++++++++++++- refs.c | 9 +++-- refs.h | 1 + t/t0600-reffiles-backend.sh | 32 ++++++++++++++++ t/t1400-update-ref.sh | 65 ++++++++++++++++++++++++++++++++ t/t1416-ref-transaction-hooks.sh | 3 ++ t/t5605-clone-local.sh | 2 +- 9 files changed, 146 insertions(+), 6 deletions(-)
Documentation/git-update-ref.txt +6 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-create SP <ref> SP <new-target> LF symref-delete SP <ref> [SP <old-target>] LF symref-verify SP <ref> [SP <old-target>] LF option SP <opt> LF
@@ -88,6 +89,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-create SP <ref> NUL <new-target> NUL symref-delete SP <ref> [NUL <old-target>] NUL symref-verify SP <ref> [NUL <old-target>] NUL option SP <opt> NUL
@@ -121,6 +123,10 @@ verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist. +symref-create: + Create symbolic ref <ref> with <new-target> after verifying + it does not exist. + symref-delete:: Delete <ref> after verifying it exists with <old-target>, if given.
builtin/clone.c +1 -1
@@ -576,7 +576,7 @@ static void write_remote_refs(const struct ref *local_refs)if (!r->peer_ref)continue ;if (ref_transaction_create (t, r->peer_ref->name, &r->old_oid, -0 ,NULL , &err)) +NULL ,0 ,NULL , &err))die ("%s" , err.buf); }
builtin/update-ref.c +31 -1
@@ -257,7 +257,7 @@ static void parse_cmd_create(struct ref_transaction *transaction,if (*next != line_termination)die ("create %s: extra input: %s" , refname, next); -if (ref_transaction_create (transaction, refname, &new_oid, +if (ref_transaction_create (transaction, refname, &new_oid,NULL , update_flags | create_reflog_flag, msg, &err))die ("%s" , err.buf);
@@ -267,6 +267,35 @@ static void parse_cmd_create(struct ref_transaction *transaction,strbuf_release (&err); } + +static void parse_cmd_symref_create (struct ref_transaction *transaction, +const char *next,const char *end) +{ +struct strbuf err =STRBUF_INIT ; +char *refname, *new_target; + + refname =parse_refname (&next); +if (!refname) +die ("symref-create: missing <ref>" ); + + new_target =parse_next_refname (&next); +if (!new_target) +die ("symref-create %s: missing <new-target>" , refname); + +if (*next != line_termination) +die ("symref-create %s: extra input: %s" , refname, next); + +if (ref_transaction_create (transaction, refname,NULL , new_target, + update_flags | create_reflog_flag, + msg, &err)) +die ("%s" , err.buf); + + update_flags = default_flags; +free (refname); +free (new_target); +strbuf_release (&err); +} +static void parse_cmd_delete (struct ref_transaction *transaction,const char *next,const char *end) {
@@ -473,6 +502,7 @@ static const struct parse_cmd { { "create", parse_cmd_create, 2, UPDATE_REFS_OPEN }, { "delete", parse_cmd_delete, 2, UPDATE_REFS_OPEN }, { "verify", parse_cmd_verify, 2, UPDATE_REFS_OPEN }, + { "symref-create", parse_cmd_symref_create, 2, UPDATE_REFS_OPEN }, { "symref-delete", parse_cmd_symref_delete, 2, UPDATE_REFS_OPEN }, { "symref-verify", parse_cmd_symref_verify, 2, UPDATE_REFS_OPEN }, { "option", parse_cmd_option, 1, UPDATE_REFS_OPEN },
refs.c +6 -3
@@ -1268,15 +1268,18 @@ int ref_transaction_update(struct ref_transaction *transaction,int ref_transaction_create (struct ref_transaction *transaction,const char *refname,const struct object_id *new_oid, +const char *new_target,unsigned int flags,const char *msg,struct strbuf *err) { -if (!new_oid ||is_null_oid (new_oid)) { -strbuf_addf (err,"'%s' has a null OID" , refname); +if (new_oid && new_target) +BUG ("create called with both new_oid and new_target set" ); +if ((!new_oid ||is_null_oid (new_oid)) && !new_target) { +strbuf_addf (err,"'%s' has neither a valid OID nor a target" , refname);return 1 ; }return ref_transaction_update (transaction, refname, new_oid, -null_oid (),NULL ,NULL , flags, +null_oid (), new_target,NULL , flags, msg, err); }
refs.h +1 -0
@@ -708,6 +708,7 @@ int ref_transaction_update(struct ref_transaction *transaction,int ref_transaction_create (struct ref_transaction *transaction,const char *refname,const struct object_id *new_oid, +const char *new_target,unsigned int flags,const char *msg,struct strbuf *err);
t/t0600-reffiles-backend.sh +32 -0
@@ -468,4 +468,36 @@ test_expect_success POSIXPERM 'git reflog expire honors core.sharedRepository' ' esac ' +test_expect_success SYMLINKS 'symref transaction supports symlinks' ' + test_when_finished "git symbolic-ref -d TEST_SYMREF_HEAD" && + git update-ref refs/heads/new @ && + test_config core.prefersymlinkrefs true && + cat >stdin <<-EOF && + start + symref-create TEST_SYMREF_HEAD refs/heads/new + prepare + commit + EOF + git update-ref --no-deref --stdin <stdin && + test_path_is_symlink .git/TEST_SYMREF_HEAD && + test "$(test_readlink .git/TEST_SYMREF_HEAD)" = refs/heads/new +' + +test_expect_success 'symref transaction supports false symlink config' ' + test_when_finished "git symbolic-ref -d TEST_SYMREF_HEAD" && + git update-ref refs/heads/new @ && + test_config core.prefersymlinkrefs false && + cat >stdin <<-EOF && + start + symref-create TEST_SYMREF_HEAD refs/heads/new + prepare + commit + EOF + git update-ref --no-deref --stdin <stdin && + test_path_is_file .git/TEST_SYMREF_HEAD && + git symbolic-ref TEST_SYMREF_HEAD >actual && + echo refs/heads/new >expect && + test_cmp expect actual +' + test_done
t/t1400-update-ref.sh +65 -0
71 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +3 -0
@@ -189,15 +189,18 @@ test_expect_success 'hook gets all queued symref updates' ' prepared ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd + $ZERO_OID ref:refs/heads/main refs/heads/symrefc committed ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd + $ZERO_OID ref:refs/heads/main refs/heads/symrefc EOF git update-ref --no-deref --stdin <<-EOF && start symref-verify refs/heads/symref refs/heads/main symref-delete refs/heads/symrefd refs/heads/main + symref-create refs/heads/symrefc refs/heads/main prepare commit EOF
t/t5605-clone-local.sh +1 -1
@@ -163,7 +163,7 @@ test_expect_success REFFILES 'local clone from repo with corrupt refs fails grac echo a >corrupt/.git/refs/heads/topic && test_must_fail git clone corrupt working 2>err && - grep "has a null OID" err + grep "has neither a valid OID nor a target" err ' test_done
Signature · 1 line
2.43.GIT
PATCH v5 6/7 reftable: pick either 'oid' or 'target' for new updates
In reply to Karthik NayakFrom: Karthik Nayak <[email protected]>
When creating a reference transaction update, we can provide the old/new oid/target for the update. We have checks in place to ensure that for each old/new, either oid or target is set and not both.
In the reftable backend, when dealing with updates without the REF_NO_DEREF flag, we don't selectively propagate data as needed. Since there are no active users of the path, this is not caught. As we want to introduce the 'symref-update' command in the upcoming commit, which would use this flow, correct it.
--- refs/reftable-backend.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
refs/reftable-backend.c +3 -2
@@ -895,8 +895,9 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,*/ new_update =ref_transaction_add_update ( transaction, referent.buf, new_flags, - &u->new_oid, &u->old_oid, u->new_target, - u->old_target, u->msg); + u->new_target ?NULL : &u->new_oid, + u->old_target ?NULL : &u->old_oid, + u->new_target, u->old_target, u->msg); new_update->parent_update = u;
Signature · 1 line
2.43.GIT
PATCH v5 7/7 update-ref: add support for 'symref-update' command
In reply to Karthik NayakFrom: Karthik Nayak <[email protected]>
Add 'symref-update' command to the '--stdin' mode of 'git-update-ref' to allow updates of symbolic refs. The 'symref-update' command takes in a <new-target>, which the <ref> will be updated to. If the <ref> doesn't exist it will be created.
It also optionally takes either an ref <old-target> or oid <old-oid>. If the <old-target> is provided, it checks to see if the <ref> targets the <old-target> before the update. If <old-oid> is provided it checks <ref> to ensure that it is a regular ref and <old-oid> is the OID before the update. This by extension also means that this when a zero <old-oid> is provided, it ensures that the ref didn't exist before.
The divergence in syntax from the regular update command is because if we don't use a (ref | oid) prefix for the old_value, then there is ambiguity around if the value provided should be treated as an oid or a reference. This is more so the reason, because we allow anything committish to be provided as an oid. While 'symref-verify' and 'symref-delete' also take in <old-target> we do not have this divergence there as those commands only work with symrefs. Whereas 'symref-update' also works with regular refs and allows users to convert regular refs to symrefs.
The command allows users to perform symbolic ref updates within a transaction. This provides atomicity and allows users to perform a set of operations together.
This command supports deref mode, to ensure that we can update dereferenced regular refs to symrefs.
--- Documentation/git-update-ref.txt | 7 ++ builtin/update-ref.c | 92 ++++++++++++++ t/t1400-update-ref.sh | 203 +++++++++++++++++++++++++++++++ t/t1416-ref-transaction-hooks.sh | 4 + 4 files changed, 306 insertions(+)
Documentation/git-update-ref.txt +7 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-update SP <ref> SP <new-target> [SP (ref SP <old-target> | oid SP <old-oid>)] LF symref-create SP <ref> SP <new-target> LF symref-delete SP <ref> [SP <old-target>] LF symref-verify SP <ref> [SP <old-target>] LF
@@ -89,6 +90,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-update SP <ref> NUL <new-target> [NUL (ref NUL <old-target> | oid NUL <old-oid>)] NUL symref-create SP <ref> NUL <new-target> NUL symref-delete SP <ref> [NUL <old-target>] NUL symref-verify SP <ref> [NUL <old-target>] NUL
@@ -119,6 +121,11 @@ delete:: Delete <ref> after verifying it exists with <old-oid>, if given. If given, <old-oid> may not be zero. +symref-update:: + Set <ref> to <new-target> after verifying <old-target> or <old-oid>, + if given. Specify a zero <old-oid> to ensure that the ref does not + exist before the update. + verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist.
builtin/update-ref.c +92 -0
110 lines not on this page · raw message
t/t1400-update-ref.sh +203 -0
215 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +4 -0
@@ -163,6 +163,7 @@ test_expect_success 'hook gets all queued symref updates' ' git update-ref refs/heads/branch $POST_OID && git symbolic-ref refs/heads/symref refs/heads/main && git symbolic-ref refs/heads/symrefd refs/heads/main && + git symbolic-ref refs/heads/symrefu refs/heads/main && test_hook reference-transaction <<-\EOF && echo "$*" >>actual
@@ -190,10 +191,12 @@ test_expect_success 'hook gets all queued symref updates' ' ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd $ZERO_OID ref:refs/heads/main refs/heads/symrefc + ref:refs/heads/main ref:refs/heads/branch refs/heads/symrefu committed ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd $ZERO_OID ref:refs/heads/main refs/heads/symrefc + ref:refs/heads/main ref:refs/heads/branch refs/heads/symrefu EOF git update-ref --no-deref --stdin <<-EOF &&
@@ -201,6 +204,7 @@ test_expect_success 'hook gets all queued symref updates' ' symref-verify refs/heads/symref refs/heads/main symref-delete refs/heads/symrefd refs/heads/main symref-create refs/heads/symrefc refs/heads/main + symref-update refs/heads/symrefu refs/heads/branch ref refs/heads/main prepare commit EOF
Signature · 1 line
2.43.GIT
PATCH v4 1/7 refs: create and use `ref_update_expects_existing_old_ref()`
In reply to a message not in the archiveFrom: Karthik Nayak <[email protected]>
The files and reftable backend, need to check if a ref must exist, so that the required validation can be done. A ref must exist only when the old_oid value of the update has been explicitly set and it is not the null_oid value.
Since we also support symrefs now, we need to ensure that even when old_target is set a ref must exist. While this was missed when we added symref support in transactions, there are no active users of this path. As we introduce the 'symref-verify' command in the upcoming commits, it is important to fix this.
So let's export this to a function called ref_update_expects_existing_old_ref() and expose it internally via 'refs-internal.h'.
--- refs.c | 6 ++++++ refs/files-backend.c | 3 +-- refs/refs-internal.h | 6 ++++++ refs/reftable-backend.c | 2 +- 4 files changed, 14 insertions(+), 3 deletions(-)
refs.c +6 -0
@@ -2679,3 +2679,9 @@ int ref_update_check_old_target(const char *referent, struct ref_update *update, referent, update->old_target);return -1 ; } + +int ref_update_expects_existing_old_ref (struct ref_update *update) +{ +return (update->flags &REF_HAVE_OLD ) && + (!is_null_oid (&update->old_oid) || update->old_target); +}
refs/files-backend.c +1 -2
@@ -2412,8 +2412,7 @@ static int lock_ref_for_update(struct files_ref_store *refs, struct strbuf *err) {struct strbuf referent =STRBUF_INIT ; -int mustexist = (update->flags &REF_HAVE_OLD ) && - !is_null_oid (&update->old_oid); +int mustexist =ref_update_expects_existing_old_ref (update);int ret =0 ;struct ref_lock *lock;
refs/refs-internal.h +6 -0
@@ -765,4 +765,10 @@ int ref_update_has_null_new_value(struct ref_update *update);int ref_update_check_old_target (const char *referent,struct ref_update *update,struct strbuf *err); +/* +* Check if the ref must exist, this means that the old_oid or +* old_target is non NULL. +*/ +int ref_update_expects_existing_old_ref (struct ref_update *update); +#endif /* REFS_REFS_INTERNAL_H */
refs/reftable-backend.c +1 -1
@@ -824,7 +824,7 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store, ¤t_oid, &referent, &u->type);if (ret <0 ) goto done; -if (ret >0 && (!(u->flags &REF_HAVE_OLD ) ||is_null_oid (&u->old_oid))) { +if (ret >0 && !ref_update_expects_existing_old_ref (u)) {/* * The reference does not exist, and we either have no * old object ID or expect the reference to not exist.
Signature · 1 line
2.43.GIT
PATCH v4 2/7 refs: specify error for regular refs with `old_target`
In reply to a message not in the archiveFrom: Karthik Nayak <[email protected]>
When a regular reference update contains old_target set, we call the ref_update_check_old_target function to check the referent value. But for regular refs we know that the referent value is not set and this simply raises a generic error which says nothing about this being a regular ref. Instead let's raise a more specific error when a regular ref update contains old_target.
--- refs/files-backend.c | 13 +++++++------ refs/reftable-backend.c | 9 +++++++++ 2 files changed, 16 insertions(+), 6 deletions(-)
refs/files-backend.c +7 -6
@@ -2491,14 +2491,15 @@ static int lock_ref_for_update(struct files_ref_store *refs,/* * Even if the ref is a regular ref, if `old_target` is set, we -* check the referent value. Ideally `old_target` should only -* be set for symrefs, but we're strict about its usage. +* fail with an error. */ if (update->old_target) { -if (ref_update_check_old_target (referent.buf, update, err)) { - ret =TRANSACTION_GENERIC_ERROR ; - goto out; - } +strbuf_addf (err,_ ("cannot update regular ref: '%s': " +"symref target '%s' set" ), +ref_update_original_update_refname (update), + update->old_target); + ret =TRANSACTION_GENERIC_ERROR ; + goto out; }else if (check_old_oid (update, &lock->old_oid, err)) { ret =TRANSACTION_GENERIC_ERROR ; goto out;
refs/reftable-backend.c +9 -0
@@ -928,6 +928,15 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,* backend returns, which keeps our tests happy. */ if (u->old_target) { +if (!(u->type &REF_ISSYMREF )) { +strbuf_addf (err,_ ("cannot update regular ref: '%s': " +"symref target '%s' set" ), +ref_update_original_update_refname (u), + u->old_target); + ret =-1 ; + goto done; + } +if (ref_update_check_old_target (referent.buf, u, err)) { ret =-1 ; goto done;
Signature · 1 line
2.43.GIT
Re: [PATCH v4 2/7] refs: specify error for regular refs with `old_target`
Quoted 3 lines · Karthik Nayak
From: Karthik Nayak <[email protected]>
When a regular reference update contains
old_targetset, we call the
s/contains/has its/
Quoted 2 lines
ref_update_check_old_targetfunction to check the referent value. But for regular refs we know that the referent value is not set and this
This is fairly technical and focussed on the implementation. Can we maybe talk more about intent ("expected a symref, but is a direct ref") rather than the exact implementation to make the commit message a bit easier to understand for folks?
Quoted 3 lines
simply raises a generic error which says nothing about this being a regular ref. Instead let's raise a more specific error when a regular ref update contains
old_target.
It might be helpful to include before/after in this commit message to show the change. Even better would be a test of course, but I think we cannot add one at this point in time yet.
Quoted 19 lines
Signed-off-by Karthik Nayak <[email protected]>--- refs/files-backend.c | 13 +++++++------ refs/reftable-backend.c | 9 +++++++++ 2 files changed, 16 insertions(+), 6 deletions(-)refs/files-backend.c +1
-2@@ -2491,14 +2491,15 @@ static int lock_ref_for_update(struct files_ref_store *refs,/* * Even if the ref is a regular ref, if `old_target` is set, we -* check the referent value. Ideally `old_target` should only -* be set for symrefs, but we're strict about its usage. +* fail with an error. */ if (update->old_target) {
refs/files-backend.c static int lock_ref_for_update(struct files_ref_store *refs, · line 2502
Quoted 10 lines
refs/files-backend.c +6
-4-if (ref_update_check_old_target (referent.buf, update, err)) { - ret =TRANSACTION_GENERIC_ERROR ; - goto out; - } +strbuf_addf (err,_ ("cannot update regular ref: '%s': " +"symref target '%s' set" ), +ref_update_original_update_refname (update), + update->old_target); + ret =TRANSACTION_GENERIC_ERROR ; + goto out;
I feel like these error messages are somewhat technical. If I were reading it as a user, I don't think I'd understand what it is trying to tell me. How about:
strbuf_addf(err, _("cannot lock ref '%s': %s",
"expected symref but is a direct ref"));This also matches the other error messages we have in this function more closely. The same is true for the equivalent in the reftable backend.
Patrick
Re: [PATCH v4 2/7] refs: specify error for regular refs with `old_target`
Quoted 7 lines · Patrick Steinhardt
Quoted 3 lines · Karthik Nayak
From: Karthik Nayak <[email protected]>
When a regular reference update contains
old_targetset, we call thes/contains/has its/
Quoted 8 lines
Quoted 2 lines
ref_update_check_old_targetfunction to check the referent value. But for regular refs we know that the referent value is not set and thisThis is fairly technical and focussed on the implementation. Can we maybe talk more about intent ("expected a symref, but is a direct ref") rather than the exact implementation to make the commit message a bit easier to understand for folks?
Fair enough, will change this.
Quoted 8 lines
Quoted 3 lines
simply raises a generic error which says nothing about this being a regular ref. Instead let's raise a more specific error when a regular ref update contains
old_target.It might be helpful to include before/after in this commit message to show the change. Even better would be a test of course, but I think we cannot add one at this point in time yet.
Yeah will do.
Yeah, adding a test is only possible in the commit where we introduce symref-delete and we do test it there.
Quoted 34 lines
Quoted 19 lines
Signed-off-by Karthik Nayak <[email protected]>--- refs/files-backend.c | 13 +++++++------ refs/reftable-backend.c | 9 +++++++++ 2 files changed, 16 insertions(+), 6 deletions(-)refs/files-backend.c +1
-2@@ -2491,14 +2491,15 @@ static int lock_ref_for_update(struct files_ref_store *refs,/* * Even if the ref is a regular ref, if `old_target` is set, we -* check the referent value. Ideally `old_target` should only -* be set for symrefs, but we're strict about its usage. +* fail with an error. */ if (update->old_target) {refs/files-backend.c static int lock_ref_for_update(struct files_ref_store *refs, · line 2502
Quoted 10 lines
refs/files-backend.c +6
-4-if (ref_update_check_old_target (referent.buf, update, err)) { - ret =TRANSACTION_GENERIC_ERROR ; - goto out; - } +strbuf_addf (err,_ ("cannot update regular ref: '%s': " +"symref target '%s' set" ), +ref_update_original_update_refname (update), + update->old_target); + ret =TRANSACTION_GENERIC_ERROR ; + goto out;I feel like these error messages are somewhat technical. If I were reading it as a user, I don't think I'd understand what it is trying to tell me. How about:
Quoted 8 lines
strbuf_addf(err, _("cannot lock ref '%s': %s", "expected symref but is a direct ref"));This also matches the other error messages we have in this function more closely. The same is true for the equivalent in the reftable backend.
Patrick
I do want to also note that there is a old_target set so perhaps
modified refs/files-backend.c
@@ -2494,8 +2494,9 @@ static int lock_ref_for_update(struct files_ref_store *refs,
* fail with an error.
*/
if (update->old_target) {
- strbuf_addf(err, _("cannot update regular ref: '%s': "
- "symref target '%s' set"),
+ strbuf_addf(err, _("cannot lock ref '%s': "
+ "expected symref with target '%s': "
+ "but is a regular ref"),
ref_update_original_update_refname(update), update->old_target);
ret = TRANSACTION_GENERIC_ERROR;
PATCH v4 3/7 update-ref: add support for 'symref-verify' command
In reply to a message not in the archiveFrom: Karthik Nayak <[email protected]>
The 'symref-verify' command allows users to verify if a provided <ref> contains the provided <old-target> without changing the <ref>. If <old-target> is not provided, the command will verify that the <ref> doesn't exist.
The command allows users to verify symbolic refs within a transaction, and this means users can perform a set of changes in a transaction only when the verification holds good.
Since we're checking for symbolic refs, this command will only work with the 'no-deref' mode. This is because any dereferenced symbolic ref will point to an object and not a ref and the regular 'verify' command can be used in such situations.
Add required tests for symref support in 'verify'. Since we're here, also add reflog checks for the pre-existing 'verify' tests, there is no divergence from behavior, but we never tested to ensure that reflog wasn't affected by the 'verify' command.
--- Documentation/git-update-ref.txt | 7 +++ builtin/update-ref.c | 80 +++++++++++++++++++++++---- refs.c | 11 +++- refs.h | 1 + t/t1400-update-ref.sh | 94 +++++++++++++++++++++++++++++++- t/t1416-ref-transaction-hooks.sh | 30 ++++++++++ 6 files changed, 208 insertions(+), 15 deletions(-)
Documentation/git-update-ref.txt +7 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-verify SP <ref> [SP <old-target>] LF option SP <opt> LF start LF prepare LF
@@ -86,6 +87,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-verify SP <ref> [NUL <old-target>] NUL option SP <opt> NUL start NUL prepare NUL
@@ -117,6 +119,11 @@ verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist. +symref-verify:: + Verify symbolic <ref> against <old-target> but do not change it. + If <old-target> is missing, the ref must not exist. Can only be + used in `no-deref` mode. + option:: Modify the behavior of the next command naming a <ref>. The only valid option is `no-deref` to avoid dereferencing
builtin/update-ref.c +70 -10
102 lines not on this page · raw message
refs.c +8 -3
@@ -1297,14 +1297,19 @@ int ref_transaction_delete(struct ref_transaction *transaction,int ref_transaction_verify (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, +const char *old_target,unsigned int flags,struct strbuf *err) { -if (!old_oid) -BUG ("verify called with old_oid set to NULL" ); +if (!old_target && !old_oid) +BUG ("verify called with old_oid and old_target set to NULL" ); +if (old_oid && old_target) +BUG ("verify called with both old_oid and old_target set" ); +if (old_target && !(flags &REF_NO_DEREF )) +BUG ("verify cannot operate on symrefs with deref mode" );return ref_transaction_update (transaction, refname,NULL , old_oid, -NULL ,NULL , +NULL , old_target, flags,NULL , err); }
refs.h +1 -0
@@ -736,6 +736,7 @@ int ref_transaction_delete(struct ref_transaction *transaction,int ref_transaction_verify (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, +const char *old_target,unsigned int flags,struct strbuf *err);
t/t1400-update-ref.sh +92 -2
113 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +30 -0
@@ -157,4 +157,34 @@ test_expect_success 'hook captures git-symbolic-ref updates' ' test_cmp expect actual ' +test_expect_success 'hook gets all queued symref updates' ' + test_when_finished "rm actual" && + + git update-ref refs/heads/branch $POST_OID && + git symbolic-ref refs/heads/symref refs/heads/main && + + test_hook reference-transaction <<-\EOF && + echo "$*" >>actual + while read -r line + do + printf "%s\n" "$line" + done >>actual + EOF + + cat >expect <<-EOF && + prepared + ref:refs/heads/main $ZERO_OID refs/heads/symref + committed + ref:refs/heads/main $ZERO_OID refs/heads/symref + EOF + + git update-ref --no-deref --stdin <<-EOF && + start + symref-verify refs/heads/symref refs/heads/main + prepare + commit + EOF + test_cmp expect actual +' + test_done
Signature · 1 line
2.43.GIT
PATCH v4 4/7 update-ref: add support for 'symref-delete' command
In reply to a message not in the archiveFrom: Karthik Nayak <[email protected]>
Add a new command 'symref-delete' to allow deletions of symbolic refs in a transaction via the '--stdin' mode of the 'git-update-ref' command. The 'symref-delete' command can, when given an <old-target>, delete the provided <ref> only when it points to <old-target>.
This command is only compatible with the 'no-deref' mode because we optionally want to check the 'old_target' of the ref being deleted. De-referencing a symbolic ref would provide a regular ref and we already have the 'delete' command for regular refs.
While users can also use 'git symbolic-ref -d' to delete symbolic refs, the 'symref-delete' command in 'git-update-ref' allows users to do so within a transaction, which promises atomicity of the operation and can be batched with other commands.
When no 'old_target' is provided it can also delete regular refs, similar to how the 'delete' command can delete symrefs when no 'old_oid' is provided.
--- Documentation/git-update-ref.txt | 5 +++ builtin/fetch.c | 4 +- builtin/receive-pack.c | 3 +- builtin/update-ref.c | 33 +++++++++++++++- refs.c | 14 +++++-- refs.h | 4 +- t/t1400-update-ref.sh | 68 ++++++++++++++++++++++++++++++++ t/t1416-ref-transaction-hooks.sh | 19 ++++++++- 8 files changed, 140 insertions(+), 10 deletions(-)
Documentation/git-update-ref.txt +5 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-delete SP <ref> [SP <old-target>] LF symref-verify SP <ref> [SP <old-target>] LF option SP <opt> LF start LF
@@ -87,6 +88,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-delete SP <ref> [NUL <old-target>] NUL symref-verify SP <ref> [NUL <old-target>] NUL option SP <opt> NUL start NUL
@@ -119,6 +121,9 @@ verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist. +symref-delete:: + Delete <ref> after verifying it exists with <old-target>, if given. + symref-verify:: Verify symbolic <ref> against <old-target> but do not change it. If <old-target> is missing, the ref must not exist. Can only be
builtin/fetch.c +2 -2
@@ -1386,8 +1386,8 @@ static int prune_refs(struct display_state *display_state,if (!dry_run) {if (transaction) {for (ref = stale_refs; ref; ref = ref->next) { - result =ref_transaction_delete (transaction, ref->name,NULL ,0 , -"fetch: prune" , &err); + result =ref_transaction_delete (transaction, ref->name,NULL , +NULL ,0 ,"fetch: prune" , &err);if (result) goto cleanup; }
builtin/receive-pack.c +2 -1
@@ -1576,7 +1576,8 @@ static const char *update(struct command *cmd, struct shallow_info *si)if (ref_transaction_delete (transaction, namespaced_name, old_oid, -0 ,"push" , &err)) { +NULL ,0 , +"push" , &err)) {rp_error ("%s" , err.buf); ret ="failed to delete" ; }else {
builtin/update-ref.c +32 -1
@@ -293,7 +293,7 @@ static void parse_cmd_delete(struct ref_transaction *transaction,if (ref_transaction_delete (transaction, refname, have_old ? &old_oid :NULL , - update_flags, msg, &err)) +NULL , update_flags, msg, &err))die ("%s" , err.buf); update_flags = default_flags;
@@ -301,6 +301,36 @@ static void parse_cmd_delete(struct ref_transaction *transaction,strbuf_release (&err); } + +static void parse_cmd_symref_delete (struct ref_transaction *transaction, +const char *next,const char *end) +{ +struct strbuf err =STRBUF_INIT ; +char *refname, *old_target; + +if (!(update_flags &REF_NO_DEREF )) +die ("symref-delete: cannot operate with deref mode" ); + + refname =parse_refname (&next); +if (!refname) +die ("symref-delete: missing <ref>" ); + + old_target =parse_next_refname (&next); + +if (*next != line_termination) +die ("symref-delete %s: extra input: %s" , refname, next); + +if (ref_transaction_delete (transaction, refname,NULL , + old_target, update_flags, msg, &err)) +die ("%s" , err.buf); + + update_flags = default_flags; +free (refname); +free (old_target); +strbuf_release (&err); +} + +static void parse_cmd_verify (struct ref_transaction *transaction,const char *next,const char *end) {
@@ -443,6 +473,7 @@ static const struct parse_cmd { { "create", parse_cmd_create, 2, UPDATE_REFS_OPEN }, { "delete", parse_cmd_delete, 2, UPDATE_REFS_OPEN }, { "verify", parse_cmd_verify, 2, UPDATE_REFS_OPEN }, + { "symref-delete", parse_cmd_symref_delete, 2, UPDATE_REFS_OPEN }, { "symref-verify", parse_cmd_symref_verify, 2, UPDATE_REFS_OPEN }, { "option", parse_cmd_option, 1, UPDATE_REFS_OPEN }, { "start", parse_cmd_start, 0, UPDATE_REFS_STARTED },
refs.c +10 -4
@@ -950,7 +950,7 @@ int refs_delete_ref(struct ref_store *refs, const char *msg, transaction =ref_store_transaction_begin (refs, &err);if (!transaction ||ref_transaction_delete (transaction, refname, old_oid, - flags, msg, &err) || +NULL , flags, msg, &err) ||ref_transaction_commit (transaction, &err)) {error ("%s" , err.buf);ref_transaction_free (transaction);
@@ -1283,14 +1283,20 @@ int ref_transaction_create(struct ref_transaction *transaction,int ref_transaction_delete (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, -unsigned int flags,const char *msg, +const char *old_target, +unsigned int flags, +const char *msg,struct strbuf *err) {if (old_oid &&is_null_oid (old_oid))BUG ("delete called with old_oid set to zeros" ); +if (old_oid && old_target) +BUG ("delete called with both old_oid and old_target set" ); +if (old_target && !(flags &REF_NO_DEREF )) +BUG ("delete cannot operate on symrefs with deref mode" );return ref_transaction_update (transaction, refname,null_oid (), old_oid, -NULL ,NULL , flags, +NULL , old_target, flags, msg, err); }
@@ -2599,7 +2605,7 @@ int refs_delete_refs(struct ref_store *refs, const char *logmsg,for_each_string_list_item (item, refnames) { ret =ref_transaction_delete (transaction, item->string, -NULL , flags, msg, &err); +NULL ,NULL , flags, msg, &err);if (ret) {warning (_ ("could not delete reference %s: %s" ), item->string, err.buf);
refs.h +3 -1
@@ -722,7 +722,9 @@ int ref_transaction_create(struct ref_transaction *transaction,int ref_transaction_delete (struct ref_transaction *transaction,const char *refname,const struct object_id *old_oid, -unsigned int flags,const char *msg, +const char *old_target, +unsigned int flags, +const char *msg,struct strbuf *err);/*
t/t1400-update-ref.sh +68 -0
74 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +18 -1
@@ -162,6 +162,7 @@ test_expect_success 'hook gets all queued symref updates' ' git update-ref refs/heads/branch $POST_OID && git symbolic-ref refs/heads/symref refs/heads/main && + git symbolic-ref refs/heads/symrefd refs/heads/main && test_hook reference-transaction <<-\EOF && echo "$*" >>actual
@@ -171,16 +172,32 @@ test_expect_success 'hook gets all queued symref updates' ' done >>actual EOF - cat >expect <<-EOF && + # In the files backend, "delete" also triggers an additional transaction + # update on the packed-refs backend, which constitutes additional reflog + # entries. + if test_have_prereq REFFILES + then + cat >expect <<-EOF + aborted + $ZERO_OID $ZERO_OID refs/heads/symrefd + EOF + else + >expect + fi && + + cat >>expect <<-EOF && prepared ref:refs/heads/main $ZERO_OID refs/heads/symref + ref:refs/heads/main $ZERO_OID refs/heads/symrefd committed ref:refs/heads/main $ZERO_OID refs/heads/symref + ref:refs/heads/main $ZERO_OID refs/heads/symrefd EOF git update-ref --no-deref --stdin <<-EOF && start symref-verify refs/heads/symref refs/heads/main + symref-delete refs/heads/symrefd refs/heads/main prepare commit EOF
Signature · 1 line
2.43.GIT
PATCH v4 5/7 update-ref: add support for 'symref-create' command
In reply to a message not in the archiveFrom: Karthik Nayak <[email protected]>
Add 'symref-create' command to the '--stdin' mode 'git-update-ref' to allow creation of symbolic refs in a transaction. The 'symref-create' command takes in a <new-target>, which the created <ref> will point to.
Also, support the 'core.prefersymlinkrefs' config, wherein if the config is set and the filesystem supports symlinks, we create the symbolic ref as a symlink. We fallback to creating a regular symref if creating the symlink is unsuccessful.
--- Documentation/git-update-ref.txt | 6 +++ builtin/clone.c | 2 +- builtin/update-ref.c | 32 +++++++++++++++- refs.c | 9 +++-- refs.h | 1 + t/t0600-reffiles-backend.sh | 32 ++++++++++++++++ t/t1400-update-ref.sh | 65 ++++++++++++++++++++++++++++++++ t/t1416-ref-transaction-hooks.sh | 3 ++ t/t5605-clone-local.sh | 2 +- 9 files changed, 146 insertions(+), 6 deletions(-)
Documentation/git-update-ref.txt +6 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-create SP <ref> SP <new-target> LF symref-delete SP <ref> [SP <old-target>] LF symref-verify SP <ref> [SP <old-target>] LF option SP <opt> LF
@@ -88,6 +89,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-create SP <ref> NUL <new-target> NUL symref-delete SP <ref> [NUL <old-target>] NUL symref-verify SP <ref> [NUL <old-target>] NUL option SP <opt> NUL
@@ -121,6 +123,10 @@ verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist. +symref-create: + Create symbolic ref <ref> with <new-target> after verifying + it does not exist. + symref-delete:: Delete <ref> after verifying it exists with <old-target>, if given.
builtin/clone.c +1 -1
@@ -576,7 +576,7 @@ static void write_remote_refs(const struct ref *local_refs)if (!r->peer_ref)continue ;if (ref_transaction_create (t, r->peer_ref->name, &r->old_oid, -0 ,NULL , &err)) +NULL ,0 ,NULL , &err))die ("%s" , err.buf); }
builtin/update-ref.c +31 -1
@@ -257,7 +257,7 @@ static void parse_cmd_create(struct ref_transaction *transaction,if (*next != line_termination)die ("create %s: extra input: %s" , refname, next); -if (ref_transaction_create (transaction, refname, &new_oid, +if (ref_transaction_create (transaction, refname, &new_oid,NULL , update_flags | create_reflog_flag, msg, &err))die ("%s" , err.buf);
@@ -267,6 +267,35 @@ static void parse_cmd_create(struct ref_transaction *transaction,strbuf_release (&err); } + +static void parse_cmd_symref_create (struct ref_transaction *transaction, +const char *next,const char *end) +{ +struct strbuf err =STRBUF_INIT ; +char *refname, *new_target; + + refname =parse_refname (&next); +if (!refname) +die ("symref-create: missing <ref>" ); + + new_target =parse_next_refname (&next); +if (!new_target) +die ("symref-create %s: missing <new-target>" , refname); + +if (*next != line_termination) +die ("symref-create %s: extra input: %s" , refname, next); + +if (ref_transaction_create (transaction, refname,NULL , new_target, + update_flags | create_reflog_flag, + msg, &err)) +die ("%s" , err.buf); + + update_flags = default_flags; +free (refname); +free (new_target); +strbuf_release (&err); +} +static void parse_cmd_delete (struct ref_transaction *transaction,const char *next,const char *end) {
@@ -473,6 +502,7 @@ static const struct parse_cmd { { "create", parse_cmd_create, 2, UPDATE_REFS_OPEN }, { "delete", parse_cmd_delete, 2, UPDATE_REFS_OPEN }, { "verify", parse_cmd_verify, 2, UPDATE_REFS_OPEN }, + { "symref-create", parse_cmd_symref_create, 2, UPDATE_REFS_OPEN }, { "symref-delete", parse_cmd_symref_delete, 2, UPDATE_REFS_OPEN }, { "symref-verify", parse_cmd_symref_verify, 2, UPDATE_REFS_OPEN }, { "option", parse_cmd_option, 1, UPDATE_REFS_OPEN },
refs.c +6 -3
@@ -1268,15 +1268,18 @@ int ref_transaction_update(struct ref_transaction *transaction,int ref_transaction_create (struct ref_transaction *transaction,const char *refname,const struct object_id *new_oid, +const char *new_target,unsigned int flags,const char *msg,struct strbuf *err) { -if (!new_oid ||is_null_oid (new_oid)) { -strbuf_addf (err,"'%s' has a null OID" , refname); +if (new_oid && new_target) +BUG ("create called with both new_oid and new_target set" ); +if ((!new_oid ||is_null_oid (new_oid)) && !new_target) { +strbuf_addf (err,"'%s' has neither a valid OID nor a target" , refname);return 1 ; }return ref_transaction_update (transaction, refname, new_oid, -null_oid (),NULL ,NULL , flags, +null_oid (), new_target,NULL , flags, msg, err); }
refs.h +1 -0
@@ -708,6 +708,7 @@ int ref_transaction_update(struct ref_transaction *transaction,int ref_transaction_create (struct ref_transaction *transaction,const char *refname,const struct object_id *new_oid, +const char *new_target,unsigned int flags,const char *msg,struct strbuf *err);
t/t0600-reffiles-backend.sh +32 -0
@@ -468,4 +468,36 @@ test_expect_success POSIXPERM 'git reflog expire honors core.sharedRepository' ' esac ' +test_expect_success SYMLINKS 'symref transaction supports symlinks' ' + test_when_finished "git symbolic-ref -d TEST_SYMREF_HEAD" && + git update-ref refs/heads/new @ && + test_config core.prefersymlinkrefs true && + cat >stdin <<-EOF && + start + symref-create TEST_SYMREF_HEAD refs/heads/new + prepare + commit + EOF + git update-ref --no-deref --stdin <stdin && + test_path_is_symlink .git/TEST_SYMREF_HEAD && + test "$(test_readlink .git/TEST_SYMREF_HEAD)" = refs/heads/new +' + +test_expect_success 'symref transaction supports false symlink config' ' + test_when_finished "git symbolic-ref -d TEST_SYMREF_HEAD" && + git update-ref refs/heads/new @ && + test_config core.prefersymlinkrefs false && + cat >stdin <<-EOF && + start + symref-create TEST_SYMREF_HEAD refs/heads/new + prepare + commit + EOF + git update-ref --no-deref --stdin <stdin && + test_path_is_file .git/TEST_SYMREF_HEAD && + git symbolic-ref TEST_SYMREF_HEAD >actual && + echo refs/heads/new >expect && + test_cmp expect actual +' + test_done
t/t1400-update-ref.sh +65 -0
71 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +3 -0
@@ -189,15 +189,18 @@ test_expect_success 'hook gets all queued symref updates' ' prepared ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd + $ZERO_OID ref:refs/heads/main refs/heads/symrefc committed ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd + $ZERO_OID ref:refs/heads/main refs/heads/symrefc EOF git update-ref --no-deref --stdin <<-EOF && start symref-verify refs/heads/symref refs/heads/main symref-delete refs/heads/symrefd refs/heads/main + symref-create refs/heads/symrefc refs/heads/main prepare commit EOF
t/t5605-clone-local.sh +1 -1
@@ -163,7 +163,7 @@ test_expect_success REFFILES 'local clone from repo with corrupt refs fails grac echo a >corrupt/.git/refs/heads/topic && test_must_fail git clone corrupt working 2>err && - grep "has a null OID" err + grep "has neither a valid OID nor a target" err ' test_done
Signature · 1 line
2.43.GIT
PATCH v4 6/7 reftable: pick either 'oid' or 'target' for new updates
In reply to a message not in the archiveFrom: Karthik Nayak <[email protected]>
When creating a reference transaction update, we can provide the old/new oid/target for the update. We have checks in place to ensure that for each old/new, either oid or target is set and not both.
In the reftable backend, when dealing with updates without the REF_NO_DEREF flag, we don't selectively propagate data as needed. Since there are no active users of the path, this is not caught. As we want to introduce the 'symref-update' command in the upcoming commit, which would use this flow, correct it.
--- refs/reftable-backend.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
refs/reftable-backend.c +3 -2
@@ -895,8 +895,9 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,*/ new_update =ref_transaction_add_update ( transaction, referent.buf, new_flags, - &u->new_oid, &u->old_oid, u->new_target, - u->old_target, u->msg); + u->new_target ?NULL : &u->new_oid, + u->old_target ?NULL : &u->old_oid, + u->new_target, u->old_target, u->msg); new_update->parent_update = u;
Signature · 1 line
2.43.GIT
PATCH v4 7/7 update-ref: add support for 'symref-update' command
In reply to a message not in the archiveFrom: Karthik Nayak <[email protected]>
Add 'symref-update' command to the '--stdin' mode of 'git-update-ref' to allow updates of symbolic refs. The 'symref-update' command takes in a <new-target>, which the <ref> will be updated to. If the <ref> doesn't exist it will be created.
It also optionally takes either an ref <old-target> or oid <old-oid>. If the <old-target> is provided, it checks to see if the <ref> targets the <old-target> before the update. If <old-oid> is provided it checks <ref> to ensure that it is a regular ref and <old-oid> is the OID before the update. This by extension also means that this when a zero <old-oid> is provided, it ensures that the ref didn't exist before.
The divergence in syntax from the regular update command is because if we don't use a (ref | oid) prefix for the old_value, then there is ambiguity around if the value provided should be treated as an oid or a reference. This is more so the reason, because we allow anything committish to be provided as an oid. While 'symref-verify' and 'symref-delete' also take in <old-target> we do not have this divergence there as those commands only work with symrefs. Whereas 'symref-update' also works with regular refs and allows users to convert regular refs to symrefs.
The command allows users to perform symbolic ref updates within a transaction. This provides atomicity and allows users to perform a set of operations together.
This command supports deref mode, to ensure that we can update dereferenced regular refs to symrefs.
--- Documentation/git-update-ref.txt | 7 ++ builtin/update-ref.c | 92 ++++++++++++++ t/t1400-update-ref.sh | 203 +++++++++++++++++++++++++++++++ t/t1416-ref-transaction-hooks.sh | 4 + 4 files changed, 306 insertions(+)
Documentation/git-update-ref.txt +7 -0
@@ -65,6 +65,7 @@ performs all modifications together. Specify commands of the form: create SP <ref> SP <new-oid> LF delete SP <ref> [SP <old-oid>] LF verify SP <ref> [SP <old-oid>] LF + symref-update SP <ref> SP <new-target> [SP (ref SP <old-target> | oid SP <old-oid>)] LF symref-create SP <ref> SP <new-target> LF symref-delete SP <ref> [SP <old-target>] LF symref-verify SP <ref> [SP <old-target>] LF
@@ -89,6 +90,7 @@ quoting: create SP <ref> NUL <new-oid> NUL delete SP <ref> NUL [<old-oid>] NUL verify SP <ref> NUL [<old-oid>] NUL + symref-update SP <ref> NUL <new-target> [NUL (ref NUL <old-target> | oid NUL <old-oid>)] NUL symref-create SP <ref> NUL <new-target> NUL symref-delete SP <ref> [NUL <old-target>] NUL symref-verify SP <ref> [NUL <old-target>] NUL
@@ -119,6 +121,11 @@ delete:: Delete <ref> after verifying it exists with <old-oid>, if given. If given, <old-oid> may not be zero. +symref-update:: + Set <ref> to <new-target> after verifying <old-target> or <old-oid>, + if given. Specify a zero <old-oid> to ensure that the ref does not + exist before the update. + verify:: Verify <ref> against <old-oid> but do not change it. If <old-oid> is zero or missing, the ref must not exist.
builtin/update-ref.c +92 -0
110 lines not on this page · raw message
t/t1400-update-ref.sh +203 -0
215 lines not on this page · raw message
t/t1416-ref-transaction-hooks.sh +4 -0
@@ -163,6 +163,7 @@ test_expect_success 'hook gets all queued symref updates' ' git update-ref refs/heads/branch $POST_OID && git symbolic-ref refs/heads/symref refs/heads/main && git symbolic-ref refs/heads/symrefd refs/heads/main && + git symbolic-ref refs/heads/symrefu refs/heads/main && test_hook reference-transaction <<-\EOF && echo "$*" >>actual
@@ -190,10 +191,12 @@ test_expect_success 'hook gets all queued symref updates' ' ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd $ZERO_OID ref:refs/heads/main refs/heads/symrefc + ref:refs/heads/main ref:refs/heads/branch refs/heads/symrefu committed ref:refs/heads/main $ZERO_OID refs/heads/symref ref:refs/heads/main $ZERO_OID refs/heads/symrefd $ZERO_OID ref:refs/heads/main refs/heads/symrefc + ref:refs/heads/main ref:refs/heads/branch refs/heads/symrefu EOF git update-ref --no-deref --stdin <<-EOF &&
@@ -201,6 +204,7 @@ test_expect_success 'hook gets all queued symref updates' ' symref-verify refs/heads/symref refs/heads/main symref-delete refs/heads/symrefd refs/heads/main symref-create refs/heads/symrefc refs/heads/main + symref-update refs/heads/symrefu refs/heads/branch ref refs/heads/main prepare commit EOF
Signature · 1 line
2.43.GIT