| Message ID | 20241209-320-git-refs-migrate-reflogs-v1-5-d4bc37ee860f@gmail.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | refs: add reflog support to `git refs migrate` | expand |
On Mon, Dec 9, 2024 at 12:11 PM Karthik Nayak <karthik.188@gmail.com> wrote: > > Introduce a new function `ref_transaction_update_reflog`, for clients to > add a reflog update to a transaction. While the existing function > `ref_transaction_update` also allows clients to add a reflog entry, this > function does a few things more, It: > - Enforces that only a reflog entry is added and does not update the > ref itself. > - Allows the users to also provide the committer information. This > means clients can add reflog entries with custom committer > information. > A follow up commit will utilize this function to add reflog support to > `git refs migrate`. > > Signed-off-by: Karthik Nayak <karthik.188@gmail.com> > --- > refs.c | 89 +++++++++++++++++++++++++++++++++++++------------ > refs.h | 12 +++++++ > refs/files-backend.c | 48 +++++++++++++++----------- > refs/refs-internal.h | 16 +++++---- > refs/reftable-backend.c | 6 ++-- > 5 files changed, 122 insertions(+), 49 deletions(-) > > diff --git a/refs.c b/refs.c > index 732c236a3fd0cf324cc172b48d3d54f6dbadf4a4..602a65873181a90751def525608a7fa7bea59562 100644 > --- a/refs.c > +++ b/refs.c > @@ -1160,13 +1160,15 @@ void ref_transaction_free(struct ref_transaction *transaction) > free(transaction); > } > > -struct ref_update *ref_transaction_add_update( > - struct ref_transaction *transaction, > - const char *refname, unsigned int flags, > - const struct object_id *new_oid, > - const struct object_id *old_oid, > - const char *new_target, const char *old_target, > - const char *msg) > +struct ref_update *ref_transaction_add_update(struct ref_transaction *transaction, > + const char *refname, > + unsigned int flags, > + const struct object_id *new_oid, > + const struct object_id *old_oid, > + const char *new_target, > + const char *old_target, > + const char *committer_info, This change (adding a 'const char *committer_info' argument to ref_transaction_add_update()) is not described in the commit message and it requires a number of changes to the callers of this function, so I think it might want to be in its own preparatory commit before this one. > + const char *msg) > { > struct ref_update *update; > > @@ -1190,8 +1192,15 @@ struct ref_update *ref_transaction_add_update( > oidcpy(&update->new_oid, new_oid); > if ((flags & REF_HAVE_OLD) && old_oid) > oidcpy(&update->old_oid, old_oid); > - if (!(flags & REF_SKIP_CREATE_REFLOG)) > + if (!(flags & REF_SKIP_CREATE_REFLOG)) { > + if (committer_info) { > + struct strbuf sb = STRBUF_INIT; > + strbuf_addstr(&sb, committer_info); > + update->committer_info = strbuf_detach(&sb, NULL); Maybe: update->committer_info = xstrdup(committer_info); > + } > + > update->msg = normalize_reflog_message(msg); > + } > > return update; > } > @@ -1199,20 +1208,29 @@ struct ref_update *ref_transaction_add_update( > static int transaction_refname_verification(const char *refname, > const struct object_id *new_oid, > unsigned int flags, > + unsigned int reflog, > struct strbuf *err) > { > if (flags & REF_SKIP_REFNAME_VERIFICATION) > return 0; > > if (is_pseudo_ref(refname)) { > - strbuf_addf(err, _("refusing to update pseudoref '%s'"), > - refname); > + if (reflog) > + strbuf_addf(err, _("refusing to update reflog for pseudoref '%s'"), > + refname); > + else > + strbuf_addf(err, _("refusing to update pseudoref '%s'"), > + refname); Maybe: const char *what = reflog ? "reflog for pseudoref" : "pseudoref"; strbuf_addf(err, _("refusing to update %s '%s'"), what, refname); > return -1; > } else if ((new_oid && !is_null_oid(new_oid)) ? > check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) : > !refname_is_safe(refname)) { > - strbuf_addf(err, _("refusing to update ref with bad name '%s'"), > - refname); > + if (reflog) > + strbuf_addf(err, _("refusing to update reflog with bad name '%s'"), > + refname); > + else > + strbuf_addf(err, _("refusing to update ref with bad name '%s'"), > + refname); Maybe: const char *what = reflog ? "reflog with bad name" : "ref with bad name"; strbuf_addf(err, _("refusing to update %s '%s'"), what, refname); > return -1; > } [...] > 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) > + const char *refname, const struct object_id *new_oid, > + const char *new_target, unsigned int flags, > + const char *msg, struct strbuf *err) This looks like a wrapping or indenting only change. If you really want to do it, it should probably be in its own preparatory commit. > index a5bedf48cf6de91005a7e8d0bf58ca98350397a6..b86d2cd87be33f7bb1b31fce711d6c7c8d9491c9 100644 > --- a/refs.h > +++ b/refs.h > @@ -727,6 +727,18 @@ int ref_transaction_update(struct ref_transaction *transaction, > unsigned int flags, const char *msg, > struct strbuf *err); > > +/* > + * Similar to `ref_transaction_update`, but this function is only for adding > + * a reflog updates. "a reflog update" or "reflog updates".
On Mon, Dec 09, 2024 at 12:07:19PM +0100, Karthik Nayak wrote: > diff --git a/refs.c b/refs.c > index 732c236a3fd0cf324cc172b48d3d54f6dbadf4a4..602a65873181a90751def525608a7fa7bea59562 100644 > --- a/refs.c > +++ b/refs.c > @@ -1160,13 +1160,15 @@ void ref_transaction_free(struct ref_transaction *transaction) > free(transaction); > } > > -struct ref_update *ref_transaction_add_update( > - struct ref_transaction *transaction, > - const char *refname, unsigned int flags, > - const struct object_id *new_oid, > - const struct object_id *old_oid, > - const char *new_target, const char *old_target, > - const char *msg) > +struct ref_update *ref_transaction_add_update(struct ref_transaction *transaction, > + const char *refname, > + unsigned int flags, > + const struct object_id *new_oid, > + const struct object_id *old_oid, > + const char *new_target, > + const char *old_target, > + const char *committer_info, > + const char *msg) > { > struct ref_update *update; > I'd personally avoid reindenting this block. It's somewhat-common practice to not align all arguments with the opening brace when the line would become too long. The reindents also distract a bit from the actual changes done in other places further down. > @@ -1190,8 +1192,15 @@ struct ref_update *ref_transaction_add_update( > oidcpy(&update->new_oid, new_oid); > if ((flags & REF_HAVE_OLD) && old_oid) > oidcpy(&update->old_oid, old_oid); > - if (!(flags & REF_SKIP_CREATE_REFLOG)) > + if (!(flags & REF_SKIP_CREATE_REFLOG)) { > + if (committer_info) { > + struct strbuf sb = STRBUF_INIT; > + strbuf_addstr(&sb, committer_info); > + update->committer_info = strbuf_detach(&sb, NULL); Can't we simplify this via `xstrdup()`? > @@ -3080,10 +3081,12 @@ static int files_transaction_finish_initial(struct files_ref_store *refs, > } > > /* > - * packed-refs don't support symbolic refs and root refs, so we > - * have to queue these references via the loose transaction. > + * packed-refs don't support symbolic refs, root refs and reflogs, > + * so we have to queue these references via the loose transaction. > */ > - if (update->new_target || is_root_ref(update->refname)) { > + if (update->new_target || > + is_root_ref(update->refname) || > + (update->flags & REF_LOG_ONLY)) { > if (!loose_transaction) { > loose_transaction = ref_store_transaction_begin(&refs->base, 0, err); > if (!loose_transaction) { Makes sense. While we already had REF_LOG_ONLY beforehand, it was only used in very specific cases and thus the support implemented by the backends is lacking. And given that the packed-ref backend does not support reflogs we have to queue these up via the loose backend. Patrick
Christian Couder <christian.couder@gmail.com> writes: [snip] >> diff --git a/refs.c b/refs.c >> index 732c236a3fd0cf324cc172b48d3d54f6dbadf4a4..602a65873181a90751def525608a7fa7bea59562 100644 >> --- a/refs.c >> +++ b/refs.c >> @@ -1160,13 +1160,15 @@ void ref_transaction_free(struct ref_transaction *transaction) >> free(transaction); >> } >> >> -struct ref_update *ref_transaction_add_update( >> - struct ref_transaction *transaction, >> - const char *refname, unsigned int flags, >> - const struct object_id *new_oid, >> - const struct object_id *old_oid, >> - const char *new_target, const char *old_target, >> - const char *msg) >> +struct ref_update *ref_transaction_add_update(struct ref_transaction *transaction, >> + const char *refname, >> + unsigned int flags, >> + const struct object_id *new_oid, >> + const struct object_id *old_oid, >> + const char *new_target, >> + const char *old_target, >> + const char *committer_info, > > This change (adding a 'const char *committer_info' argument to > ref_transaction_add_update()) is not described in the commit message > and it requires a number of changes to the callers of this function, > so I think it might want to be in its own preparatory commit before > this one. > I think this is a great suggestion, it would reduce the congnitive load of the commit and make it easier to review. Will do. >> + const char *msg) >> { >> struct ref_update *update; >> >> @@ -1190,8 +1192,15 @@ struct ref_update *ref_transaction_add_update( >> oidcpy(&update->new_oid, new_oid); >> if ((flags & REF_HAVE_OLD) && old_oid) >> oidcpy(&update->old_oid, old_oid); >> - if (!(flags & REF_SKIP_CREATE_REFLOG)) >> + if (!(flags & REF_SKIP_CREATE_REFLOG)) { >> + if (committer_info) { >> + struct strbuf sb = STRBUF_INIT; >> + strbuf_addstr(&sb, committer_info); >> + update->committer_info = strbuf_detach(&sb, NULL); > > Maybe: > update->committer_info = xstrdup(committer_info); > Indeed, I thought there was a better way. This is what I needed to have done. >> + } >> + >> update->msg = normalize_reflog_message(msg); >> + } >> >> return update; >> } >> @@ -1199,20 +1208,29 @@ struct ref_update *ref_transaction_add_update( >> static int transaction_refname_verification(const char *refname, >> const struct object_id *new_oid, >> unsigned int flags, >> + unsigned int reflog, >> struct strbuf *err) >> { >> if (flags & REF_SKIP_REFNAME_VERIFICATION) >> return 0; >> >> if (is_pseudo_ref(refname)) { >> - strbuf_addf(err, _("refusing to update pseudoref '%s'"), >> - refname); >> + if (reflog) >> + strbuf_addf(err, _("refusing to update reflog for pseudoref '%s'"), >> + refname); >> + else >> + strbuf_addf(err, _("refusing to update pseudoref '%s'"), >> + refname); > > Maybe: > > const char *what = reflog ? "reflog for pseudoref" : "pseudoref"; > strbuf_addf(err, _("refusing to update %s '%s'"), what, refname); > Much nicer, will add. >> return -1; >> } else if ((new_oid && !is_null_oid(new_oid)) ? >> check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) : >> !refname_is_safe(refname)) { >> - strbuf_addf(err, _("refusing to update ref with bad name '%s'"), >> - refname); >> + if (reflog) >> + strbuf_addf(err, _("refusing to update reflog with bad name '%s'"), >> + refname); >> + else >> + strbuf_addf(err, _("refusing to update ref with bad name '%s'"), >> + refname); > > Maybe: > > const char *what = reflog ? "reflog with bad name" : > "ref with bad name"; > strbuf_addf(err, _("refusing to update %s '%s'"), what, refname); > Similar, will do. >> return -1; >> } > > [...] > >> 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) >> + const char *refname, const struct object_id *new_oid, >> + const char *new_target, unsigned int flags, >> + const char *msg, struct strbuf *err) > > This looks like a wrapping or indenting only change. If you really > want to do it, it should probably be in its own preparatory commit. > I think it was the auto linter, will remove. >> index a5bedf48cf6de91005a7e8d0bf58ca98350397a6..b86d2cd87be33f7bb1b31fce711d6c7c8d9491c9 100644 >> --- a/refs.h >> +++ b/refs.h >> @@ -727,6 +727,18 @@ int ref_transaction_update(struct ref_transaction *transaction, >> unsigned int flags, const char *msg, >> struct strbuf *err); >> >> +/* >> + * Similar to `ref_transaction_update`, but this function is only for adding >> + * a reflog updates. > > "a reflog update" or "reflog updates". Makes sense. Thanks.
Patrick Steinhardt <ps@pks.im> writes: > On Mon, Dec 09, 2024 at 12:07:19PM +0100, Karthik Nayak wrote: >> diff --git a/refs.c b/refs.c >> index 732c236a3fd0cf324cc172b48d3d54f6dbadf4a4..602a65873181a90751def525608a7fa7bea59562 100644 >> --- a/refs.c >> +++ b/refs.c >> @@ -1160,13 +1160,15 @@ void ref_transaction_free(struct ref_transaction *transaction) >> free(transaction); >> } >> >> -struct ref_update *ref_transaction_add_update( >> - struct ref_transaction *transaction, >> - const char *refname, unsigned int flags, >> - const struct object_id *new_oid, >> - const struct object_id *old_oid, >> - const char *new_target, const char *old_target, >> - const char *msg) >> +struct ref_update *ref_transaction_add_update(struct ref_transaction *transaction, >> + const char *refname, >> + unsigned int flags, >> + const struct object_id *new_oid, >> + const struct object_id *old_oid, >> + const char *new_target, >> + const char *old_target, >> + const char *committer_info, >> + const char *msg) >> { >> struct ref_update *update; >> > > I'd personally avoid reindenting this block. It's somewhat-common > practice to not align all arguments with the opening brace when the line > would become too long. The reindents also distract a bit from the actual > changes done in other places further down. > Makes sense, I'll undo that. >> @@ -1190,8 +1192,15 @@ struct ref_update *ref_transaction_add_update( >> oidcpy(&update->new_oid, new_oid); >> if ((flags & REF_HAVE_OLD) && old_oid) >> oidcpy(&update->old_oid, old_oid); >> - if (!(flags & REF_SKIP_CREATE_REFLOG)) >> + if (!(flags & REF_SKIP_CREATE_REFLOG)) { >> + if (committer_info) { >> + struct strbuf sb = STRBUF_INIT; >> + strbuf_addstr(&sb, committer_info); >> + update->committer_info = strbuf_detach(&sb, NULL); > > Can't we simplify this via `xstrdup()`? > Yup, Christian suggested the same too, will fix it up. >> @@ -3080,10 +3081,12 @@ static int files_transaction_finish_initial(struct files_ref_store *refs, >> } >> >> /* >> - * packed-refs don't support symbolic refs and root refs, so we >> - * have to queue these references via the loose transaction. >> + * packed-refs don't support symbolic refs, root refs and reflogs, >> + * so we have to queue these references via the loose transaction. >> */ >> - if (update->new_target || is_root_ref(update->refname)) { >> + if (update->new_target || >> + is_root_ref(update->refname) || >> + (update->flags & REF_LOG_ONLY)) { >> if (!loose_transaction) { >> loose_transaction = ref_store_transaction_begin(&refs->base, 0, err); >> if (!loose_transaction) { > > Makes sense. While we already had REF_LOG_ONLY beforehand, it was only > used in very specific cases and thus the support implemented by the > backends is lacking. And given that the packed-ref backend does not > support reflogs we have to queue these up via the loose backend. > > Patrick
diff --git a/refs.c b/refs.c index 732c236a3fd0cf324cc172b48d3d54f6dbadf4a4..602a65873181a90751def525608a7fa7bea59562 100644 --- a/refs.c +++ b/refs.c @@ -1160,13 +1160,15 @@ void ref_transaction_free(struct ref_transaction *transaction) free(transaction); } -struct ref_update *ref_transaction_add_update( - struct ref_transaction *transaction, - const char *refname, unsigned int flags, - const struct object_id *new_oid, - const struct object_id *old_oid, - const char *new_target, const char *old_target, - const char *msg) +struct ref_update *ref_transaction_add_update(struct ref_transaction *transaction, + const char *refname, + unsigned int flags, + const struct object_id *new_oid, + const struct object_id *old_oid, + const char *new_target, + const char *old_target, + const char *committer_info, + const char *msg) { struct ref_update *update; @@ -1190,8 +1192,15 @@ struct ref_update *ref_transaction_add_update( oidcpy(&update->new_oid, new_oid); if ((flags & REF_HAVE_OLD) && old_oid) oidcpy(&update->old_oid, old_oid); - if (!(flags & REF_SKIP_CREATE_REFLOG)) + if (!(flags & REF_SKIP_CREATE_REFLOG)) { + if (committer_info) { + struct strbuf sb = STRBUF_INIT; + strbuf_addstr(&sb, committer_info); + update->committer_info = strbuf_detach(&sb, NULL); + } + update->msg = normalize_reflog_message(msg); + } return update; } @@ -1199,20 +1208,29 @@ struct ref_update *ref_transaction_add_update( static int transaction_refname_verification(const char *refname, const struct object_id *new_oid, unsigned int flags, + unsigned int reflog, struct strbuf *err) { if (flags & REF_SKIP_REFNAME_VERIFICATION) return 0; if (is_pseudo_ref(refname)) { - strbuf_addf(err, _("refusing to update pseudoref '%s'"), - refname); + if (reflog) + strbuf_addf(err, _("refusing to update reflog for pseudoref '%s'"), + refname); + else + strbuf_addf(err, _("refusing to update pseudoref '%s'"), + refname); return -1; } else if ((new_oid && !is_null_oid(new_oid)) ? check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) : !refname_is_safe(refname)) { - strbuf_addf(err, _("refusing to update ref with bad name '%s'"), - refname); + if (reflog) + strbuf_addf(err, _("refusing to update reflog with bad name '%s'"), + refname); + else + strbuf_addf(err, _("refusing to update ref with bad name '%s'"), + refname); return -1; } @@ -1238,7 +1256,7 @@ int ref_transaction_update(struct ref_transaction *transaction, return -1; } - ret = transaction_refname_verification(refname, new_oid, flags, err); + ret = transaction_refname_verification(refname, new_oid, flags, 0, err); if (ret) return ret; @@ -1255,18 +1273,47 @@ int ref_transaction_update(struct ref_transaction *transaction, flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0); flags |= (new_target ? REF_HAVE_NEW : 0) | (old_target ? REF_HAVE_OLD : 0); - ref_transaction_add_update(transaction, refname, flags, - new_oid, old_oid, new_target, - old_target, msg); + ref_transaction_add_update(transaction, refname, flags, new_oid, + old_oid, new_target, old_target, NULL, msg); + return 0; +} + +int ref_transaction_update_reflog(struct ref_transaction *transaction, + const char *refname, + const struct object_id *new_oid, + const struct object_id *old_oid, + const char *committer_info, unsigned int flags, + const char *msg, unsigned int index, + struct strbuf *err) +{ + struct ref_update *update; + int ret; + + assert(err); + + ret = transaction_refname_verification(refname, new_oid, flags, 1, err); + if (ret) + return ret; + + flags |= REF_LOG_ONLY | REF_NO_DEREF; + + update = ref_transaction_add_update(transaction, refname, flags, + new_oid, old_oid, NULL, NULL, + committer_info, msg); + /* + * While we do set the old_oid value, we unset the flag to skip + * old_oid verification which only makes sense for refs. + */ + update->flags &= ~REF_HAVE_OLD; + update->index = index; + return 0; } 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) + 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 && new_target) BUG("create called with both new_oid and new_target set"); diff --git a/refs.h b/refs.h index a5bedf48cf6de91005a7e8d0bf58ca98350397a6..b86d2cd87be33f7bb1b31fce711d6c7c8d9491c9 100644 --- a/refs.h +++ b/refs.h @@ -727,6 +727,18 @@ int ref_transaction_update(struct ref_transaction *transaction, unsigned int flags, const char *msg, struct strbuf *err); +/* + * Similar to `ref_transaction_update`, but this function is only for adding + * a reflog updates. Supports providing custom committer information. + */ +int ref_transaction_update_reflog(struct ref_transaction *transaction, + const char *refname, + const struct object_id *new_oid, + const struct object_id *old_oid, + const char *committer_info, unsigned int flags, + const char *msg, unsigned int index, + struct strbuf *err); + /* * Add a reference creation to transaction. new_oid is the value that * the reference should have after the update; it must not be diff --git a/refs/files-backend.c b/refs/files-backend.c index 9c929c1ac33bc62a75620e684a809d46b574f1c6..32975e0fd7a03ab8ddf99c0a68af99921d3f5090 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1268,10 +1268,10 @@ static void prune_ref(struct files_ref_store *refs, struct ref_to_prune *r) transaction = ref_store_transaction_begin(&refs->base, 0, &err); if (!transaction) goto cleanup; - ref_transaction_add_update( - transaction, r->name, - REF_NO_DEREF | REF_HAVE_NEW | REF_HAVE_OLD | REF_IS_PRUNING, - null_oid(), &r->oid, NULL, NULL, NULL); + ref_transaction_add_update(transaction, r->name, + REF_NO_DEREF | REF_HAVE_NEW | REF_HAVE_OLD | + REF_IS_PRUNING, null_oid(), &r->oid, NULL, + NULL, NULL, NULL); if (ref_transaction_commit(transaction, &err)) goto cleanup; @@ -2418,7 +2418,7 @@ static int split_head_update(struct ref_update *update, transaction, "HEAD", update->flags | REF_LOG_ONLY | REF_NO_DEREF, &update->new_oid, &update->old_oid, - NULL, NULL, update->msg); + NULL, NULL, update->committer_info, update->msg); /* * Add "HEAD". This insertion is O(N) in the transaction @@ -2482,7 +2482,8 @@ static int split_symref_update(struct ref_update *update, transaction, referent, new_flags, update->new_target ? NULL : &update->new_oid, update->old_target ? NULL : &update->old_oid, - update->new_target, update->old_target, update->msg); + update->new_target, update->old_target, NULL, + update->msg); new_update->parent_update = update; @@ -2911,11 +2912,11 @@ static int files_transaction_prepare(struct ref_store *ref_store, packed_transaction; } - ref_transaction_add_update( - packed_transaction, update->refname, - REF_HAVE_NEW | REF_NO_DEREF, - &update->new_oid, NULL, - NULL, NULL, NULL); + ref_transaction_add_update(packed_transaction, + update->refname, + REF_HAVE_NEW | REF_NO_DEREF, + &update->new_oid, NULL, NULL, + NULL, NULL, NULL); } } @@ -3080,10 +3081,12 @@ static int files_transaction_finish_initial(struct files_ref_store *refs, } /* - * packed-refs don't support symbolic refs and root refs, so we - * have to queue these references via the loose transaction. + * packed-refs don't support symbolic refs, root refs and reflogs, + * so we have to queue these references via the loose transaction. */ - if (update->new_target || is_root_ref(update->refname)) { + if (update->new_target || + is_root_ref(update->refname) || + (update->flags & REF_LOG_ONLY)) { if (!loose_transaction) { loose_transaction = ref_store_transaction_begin(&refs->base, 0, err); if (!loose_transaction) { @@ -3092,15 +3095,22 @@ static int files_transaction_finish_initial(struct files_ref_store *refs, } } - ref_transaction_add_update(loose_transaction, update->refname, - update->flags & ~REF_HAVE_OLD, - update->new_target ? NULL : &update->new_oid, NULL, - update->new_target, NULL, NULL); + if (update->flags & REF_LOG_ONLY) + ref_transaction_add_update(loose_transaction, update->refname, + update->flags, &update->new_oid, + &update->old_oid, NULL, NULL, + update->committer_info, update->msg); + else + ref_transaction_add_update(loose_transaction, update->refname, + update->flags & ~REF_HAVE_OLD, + update->new_target ? NULL : &update->new_oid, NULL, + update->new_target, NULL, update->committer_info, + NULL); } else { ref_transaction_add_update(packed_transaction, update->refname, update->flags & ~REF_HAVE_OLD, &update->new_oid, &update->old_oid, - NULL, NULL, NULL); + NULL, NULL, update->committer_info, NULL); } } diff --git a/refs/refs-internal.h b/refs/refs-internal.h index f5c733d099f0c6f1076a25f4f77d9d5eb345ec87..82c1387d1e6ab3658b31fe99c95f98645ff1ebf1 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -156,13 +156,15 @@ int ref_update_reject_duplicates(struct string_list *refnames, * dereferenced if the REF_HAVE_NEW and REF_HAVE_OLD bits, * respectively, are set in flags. */ -struct ref_update *ref_transaction_add_update( - struct ref_transaction *transaction, - const char *refname, unsigned int flags, - const struct object_id *new_oid, - const struct object_id *old_oid, - const char *new_target, const char *old_target, - const char *msg); +struct ref_update *ref_transaction_add_update(struct ref_transaction *transaction, + const char *refname, + unsigned int flags, + const struct object_id *new_oid, + const struct object_id *old_oid, + const char *new_target, + const char *old_target, + const char *committer_info, + const char *msg); /* * Transaction states. diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c index c008f20be719fec3af6a8f81c821cb9c263764d7..b2e3ba877de9e59fea5a4d066eb13e60ef22a32b 100644 --- a/refs/reftable-backend.c +++ b/refs/reftable-backend.c @@ -1078,7 +1078,8 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store, new_update = ref_transaction_add_update( transaction, "HEAD", u->flags | REF_LOG_ONLY | REF_NO_DEREF, - &u->new_oid, &u->old_oid, NULL, NULL, u->msg); + &u->new_oid, &u->old_oid, NULL, NULL, NULL, + u->msg); string_list_insert(&affected_refnames, new_update->refname); } @@ -1161,7 +1162,8 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store, transaction, referent.buf, new_flags, u->new_target ? NULL : &u->new_oid, u->old_target ? NULL : &u->old_oid, - u->new_target, u->old_target, u->msg); + u->new_target, u->old_target, + u->committer_info, u->msg); new_update->parent_update = u;
Introduce a new function `ref_transaction_update_reflog`, for clients to add a reflog update to a transaction. While the existing function `ref_transaction_update` also allows clients to add a reflog entry, this function does a few things more, It: - Enforces that only a reflog entry is added and does not update the ref itself. - Allows the users to also provide the committer information. This means clients can add reflog entries with custom committer information. A follow up commit will utilize this function to add reflog support to `git refs migrate`. Signed-off-by: Karthik Nayak <karthik.188@gmail.com> --- refs.c | 89 +++++++++++++++++++++++++++++++++++++------------ refs.h | 12 +++++++ refs/files-backend.c | 48 +++++++++++++++----------- refs/refs-internal.h | 16 +++++---- refs/reftable-backend.c | 6 ++-- 5 files changed, 122 insertions(+), 49 deletions(-)