refs: move object parsing to the generic layer

Regular reference updates made via reference transactions validate that
the provided object ID exists in the object database, which is done by
calling 'parse_object()'. This check is done independently by the
backends which leads to duplicated logic.

Let's move this to the generic layer, ensuring the backends only have to
care about reference storage and not about validation of the object IDs.
With this also remove the 'REF_TRANSACTION_ERROR_INVALID_NEW_VALUE'
error type as its no longer used.

Since we don't iterate over individual references in
`ref_transaction_prepare()`, we add this check to
`ref_transaction_update()`. This means that the validation is done as
soon as an update is queued, without needing to prepare the
transaction. It can be argued that this is more ideal, since this
validation has no dependency on the reference transaction being
prepared.

It must be noted that the change in behavior means that this error
cannot be ignored even with usage of batched updates, since this happens
when the update is being added to the transaction. But since the caller
gets specific error codes, they can either abort the transaction or
continue adding other updates to the transaction.

Modify 'builtin/receive-pack.c' to now capture the error type so that
the error propagated to the client stays the same. Also remove two of
the tests which validates batch-updates with invalid new_oid.

Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index 878aa7f0ed9eb532341c6d6758e90cb96d2d10b4..376e755e97e8ea66680c0d5ab537d1df2d08368f 100644 (file)
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -1641,8 +1641,8 @@ static const char *update(struct command *cmd, struct shallow_info *si)
                        ret = NULL; /* good */
                }
                strbuf_release(&err);
-       }
-       else {
+       } else {
+               enum ref_transaction_error tx_err;
                struct strbuf err = STRBUF_INIT;
                if (shallow_update && si->shallow_ref[cmd->index] &&
                    update_shallow_ref(cmd, si)) {
@@ -1650,14 +1650,18 @@ static const char *update(struct command *cmd, struct shallow_info *si)
                        goto out;
                }
 
-               if (ref_transaction_update(transaction,
-                                          namespaced_name,
-                                          new_oid, old_oid,
-                                          NULL, NULL,
-                                          0, "push",
-                                          &err)) {
+               tx_err = ref_transaction_update(transaction,
+                                                 namespaced_name,
+                                                 new_oid, old_oid,
+                                                 NULL, NULL,
+                                                 0, "push",
+                                                 &err);
+               if (tx_err) {
                        rp_error("%s", err.buf);
-                       ret = "failed to update ref";
+                       if (tx_err == REF_TRANSACTION_ERROR_GENERIC)
+                               ret = "failed to update ref";
+                       else
+                               ret = ref_transaction_error_msg(tx_err);
                } else {
                        ret = NULL; /* good */
                }

diff --git a/refs.c b/refs.c
index efa16b739d153b24b53ff8639cdf4e75516c9207..662a9e6f9e2048a4e8a28cb06a4de4aa3ce6d7d2 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1416,6 +1416,24 @@ enum ref_transaction_error ref_transaction_update(struct ref_transaction *transa
        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);
 
+       if ((flags & REF_HAVE_NEW) && !new_target && !is_null_oid(new_oid) &&
+           !(flags & REF_SKIP_OID_VERIFICATION) && !(flags & REF_LOG_ONLY)) {
+               struct object *o = parse_object(transaction->ref_store->repo, new_oid);
+
+               if (!o) {
+                       strbuf_addf(err,
+                                   _("trying to write ref '%s' with nonexistent object %s"),
+                                   refname, oid_to_hex(new_oid));
+                       return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
+               }
+
+               if (o->type != OBJ_COMMIT && is_branch(refname)) {
+                       strbuf_addf(err, _("trying to write non-commit object %s to branch '%s'"),
+                                   oid_to_hex(new_oid), refname);
+                       return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
+               }
+       }
+
        ref_transaction_add_update(transaction, refname, flags,
                                   new_oid, old_oid, new_target,
                                   old_target, NULL, msg);

diff --git a/refs/files-backend.c b/refs/files-backend.c
index 4b2faf477727b48878bac4c14cc835f70d61a09b..f20f580fbc96018c20039b12e77ef0c096589802 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -19,7 +19,6 @@
 #include "../iterator.h"
 #include "../dir-iterator.h"
 #include "../lockfile.h"
-#include "../object.h"
 #include "../path.h"
 #include "../dir.h"
 #include "../chdir-notify.h"
@@ -1589,7 +1588,6 @@ static int rename_tmp_log(struct files_ref_store *refs, const char *newrefname)
 static enum ref_transaction_error write_ref_to_lockfile(struct files_ref_store *refs,
                                                        struct ref_lock *lock,
                                                        const struct object_id *oid,
-                                                       int skip_oid_verification,
                                                        struct strbuf *err);
 static int commit_ref_update(struct files_ref_store *refs,
                             struct ref_lock *lock,
@@ -1737,7 +1735,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store,
        }
        oidcpy(&lock->old_oid, &orig_oid);
 
-       if (write_ref_to_lockfile(refs, lock, &orig_oid, 0, &err) ||
+       if (write_ref_to_lockfile(refs, lock, &orig_oid, &err) ||
            commit_ref_update(refs, lock, &orig_oid, logmsg, 0, &err)) {
                error("unable to write current sha1 into %s: %s", newrefname, err.buf);
                strbuf_release(&err);
@@ -1755,7 +1753,7 @@ static int files_copy_or_rename_ref(struct ref_store *ref_store,
                goto rollbacklog;
        }
 
-       if (write_ref_to_lockfile(refs, lock, &orig_oid, 0, &err) ||
+       if (write_ref_to_lockfile(refs, lock, &orig_oid, &err) ||
            commit_ref_update(refs, lock, &orig_oid, NULL, REF_SKIP_CREATE_REFLOG, &err)) {
                error("unable to write current sha1 into %s: %s", oldrefname, err.buf);
                strbuf_release(&err);
@@ -1999,32 +1997,11 @@ static int files_log_ref_write(struct files_ref_store *refs,
 static enum ref_transaction_error write_ref_to_lockfile(struct files_ref_store *refs,
                                                        struct ref_lock *lock,
                                                        const struct object_id *oid,
-                                                       int skip_oid_verification,
                                                        struct strbuf *err)
 {
        static char term = '\n';
-       struct object *o;
        int fd;
 
-       if (!skip_oid_verification) {
-               o = parse_object(refs->base.repo, oid);
-               if (!o) {
-                       strbuf_addf(
-                               err,
-                               "trying to write ref '%s' with nonexistent object %s",
-                               lock->ref_name, oid_to_hex(oid));
-                       unlock_ref(lock);
-                       return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
-               }
-               if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
-                       strbuf_addf(
-                               err,
-                               "trying to write non-commit object %s to branch '%s'",
-                               oid_to_hex(oid), lock->ref_name);
-                       unlock_ref(lock);
-                       return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
-               }
-       }
        fd = get_lock_file_fd(&lock->lk);
        if (write_in_full(fd, oid_to_hex(oid), refs->base.repo->hash_algo->hexsz) < 0 ||
            write_in_full(fd, &term, 1) < 0 ||
@@ -2828,7 +2805,6 @@ static enum ref_transaction_error lock_ref_for_update(struct files_ref_store *re
                } else {
                        ret = write_ref_to_lockfile(
                                refs, lock, &update->new_oid,
-                               update->flags & REF_SKIP_OID_VERIFICATION,
                                err);
                        if (ret) {
                                char *write_err = strbuf_detach(err, NULL);

diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 93374d25c24d2120d79153671179d11343c8aab5..444b0c24e56cd0ca942392438cabcc721391d445 100644 (file)
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -1081,25 +1081,6 @@ static enum ref_transaction_error prepare_single_update(struct reftable_ref_stor
                return 0;
        }
 
-       /* Verify that the new object ID is valid. */
-       if ((u->flags & REF_HAVE_NEW) && !is_null_oid(&u->new_oid) &&
-           !(u->flags & REF_SKIP_OID_VERIFICATION) &&
-           !(u->flags & REF_LOG_ONLY)) {
-               struct object *o = parse_object(refs->base.repo, &u->new_oid);
-               if (!o) {
-                       strbuf_addf(err,
-                                   _("trying to write ref '%s' with nonexistent object %s"),
-                                   u->refname, oid_to_hex(&u->new_oid));
-                       return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
-               }
-
-               if (o->type != OBJ_COMMIT && is_branch(u->refname)) {
-                       strbuf_addf(err, _("trying to write non-commit object %s to branch '%s'"),
-                                   oid_to_hex(&u->new_oid), u->refname);
-                       return REF_TRANSACTION_ERROR_INVALID_NEW_VALUE;
-               }
-       }
-
        /*
         * When we update the reference that HEAD points to we enqueue
         * a second log-only update for HEAD so that its reflog is