fetch: extract out reference committing logic

The `do_fetch()` function contains the core of the `git-fetch(1)` logic.
Part of this is to fetch and store references. This is done by

  1. Creating a reference transaction (non-atomic mode uses batched
     updates).
  2. Adding individual reference updates to the transaction.
  3. Committing the transaction.
  4. When using batched updates, handling the rejected updates.

The following commit, will fix a bug wherein fetching tags with
conflicts was causing other reference updates to fail. Fixing this
requires utilizing this logic in different regions of the function.

In preparation of the follow up commit, extract the committing and
rejection handling logic into a separate function called
`commit_ref_transaction()`.

Helped-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/fetch.c b/builtin/fetch.c
index c7ff3480fb182711eccca1421798387a3391a6c4..f90179040ba34c6c906ed2c06a3d88a64202091b 100644 (file)
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -1686,6 +1686,36 @@ static void ref_transaction_rejection_handler(const char *refname,
        *data->retcode = 1;
 }
 
+/*
+ * Commit the reference transaction. If it isn't an atomic transaction, handle
+ * rejected updates as part of using batched updates.
+ */
+static int commit_ref_transaction(struct ref_transaction **transaction,
+                                 bool is_atomic, const char *remote_name,
+                                 struct strbuf *err)
+{
+       int retcode = ref_transaction_commit(*transaction, err);
+       if (retcode)
+               goto out;
+
+       if (!is_atomic) {
+               struct ref_rejection_data data = {
+                       .conflict_msg_shown = 0,
+                       .remote_name = remote_name,
+                       .retcode = &retcode,
+               };
+
+               ref_transaction_for_each_rejected_update(*transaction,
+                                                        ref_transaction_rejection_handler,
+                                                        &data);
+       }
+
+out:
+       ref_transaction_free(*transaction);
+       *transaction = NULL;
+       return retcode;
+}
+
 static int do_fetch(struct transport *transport,
                    struct refspec *rs,
                    const struct fetch_config *config)
@@ -1858,33 +1888,10 @@ static int do_fetch(struct transport *transport,
        if (retcode)
                goto cleanup;
 
-       retcode = ref_transaction_commit(transaction, &err);
-       if (retcode) {
-               /*
-                * Explicitly handle transaction cleanup to avoid
-                * aborting an already closed transaction.
-                */
-               ref_transaction_free(transaction);
-               transaction = NULL;
+       retcode = commit_ref_transaction(&transaction, atomic_fetch,
+                                        transport->remote->name, &err);
+       if (retcode)
                goto cleanup;
-       }
-
-       if (!atomic_fetch) {
-               struct ref_rejection_data data = {
-                       .retcode = &retcode,
-                       .conflict_msg_shown = 0,
-                       .remote_name = transport->remote->name,
-               };
-
-               ref_transaction_for_each_rejected_update(transaction,
-                                                        ref_transaction_rejection_handler,
-                                                        &data);
-               if (retcode) {
-                       ref_transaction_free(transaction);
-                       transaction = NULL;
-                       goto cleanup;
-               }
-       }
 
        commit_fetch_head(&fetch_head);