receive-pack.c: move transaction handling in a central place

This moves all code related to transactions into the
execute_commands_non_atomic function. This includes
beginning and committing the transaction as well as
dealing with the errors which may occur during the
begin and commit phase of a transaction.

No functional changes intended.

Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index 0ccfb3d689481eaa66828005ba2dca718dfd8595..96e56a704d5ba653f9c55c21a3caeeaeb0621571 100644 (file)
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -66,6 +66,7 @@ static const char *NONCE_SLOP = "SLOP";
 static const char *nonce_status;
 static long nonce_stamp_slop;
 static unsigned long nonce_stamp_slop_limit;
 static const char *nonce_status;
 static long nonce_stamp_slop;
 static unsigned long nonce_stamp_slop_limit;

+static struct ref_transaction *transaction;

 
 static enum deny_action parse_deny_action(const char *var, const char *value)
 {
 
 static enum deny_action parse_deny_action(const char *var, const char *value)
 {


@@ -821,6 +822,7 @@ static const char *update(struct command *cmd, struct shallow_info *si)
        }
 
        if (is_null_sha1(new_sha1)) {
        }
 
        if (is_null_sha1(new_sha1)) {

+               struct strbuf err = STRBUF_INIT;

                if (!parse_object(old_sha1)) {
                        old_sha1 = NULL;
                        if (ref_exists(name)) {
                if (!parse_object(old_sha1)) {
                        old_sha1 = NULL;
                        if (ref_exists(name)) {


@@ -830,35 +832,36 @@ static const char *update(struct command *cmd, struct shallow_info *si)
                                cmd->did_not_exist = 1;
                        }
                }
                                cmd->did_not_exist = 1;
                        }
                }

-               if (delete_ref(namespaced_name, old_sha1, 0)) {
-                       rp_error("failed to delete %s", name);
+               if (ref_transaction_delete(transaction,
+                                          namespaced_name,
+                                          old_sha1,
+                                          0, old_sha1 != NULL,
+                                          "push", &err)) {
+                       rp_error("%s", err.buf);
+                       strbuf_release(&err);

                        return "failed to delete";
                }
                        return "failed to delete";
                }

+               strbuf_release(&err);

                return NULL; /* good */
        }
        else {
                struct strbuf err = STRBUF_INIT;
                return NULL; /* good */
        }
        else {
                struct strbuf err = STRBUF_INIT;

-               struct ref_transaction *transaction;
-

                if (shallow_update && si->shallow_ref[cmd->index] &&
                    update_shallow_ref(cmd, si))
                        return "shallow error";
 
                if (shallow_update && si->shallow_ref[cmd->index] &&
                    update_shallow_ref(cmd, si))
                        return "shallow error";
 

-               transaction = ref_transaction_begin(&err);
-               if (!transaction ||
-                   ref_transaction_update(transaction, namespaced_name,
-                                          new_sha1, old_sha1, 0, 1, "push",
-                                          &err) ||
-                   ref_transaction_commit(transaction, &err)) {
-                       ref_transaction_free(transaction);
-
+               if (ref_transaction_update(transaction,
+                                          namespaced_name,
+                                          new_sha1, old_sha1,
+                                          0, 1, "push",
+                                          &err)) {

                        rp_error("%s", err.buf);
                        strbuf_release(&err);
                        rp_error("%s", err.buf);
                        strbuf_release(&err);

+

                        return "failed to update ref";
                }
                        return "failed to update ref";
                }

-
-               ref_transaction_free(transaction);

                strbuf_release(&err);
                strbuf_release(&err);

+

                return NULL; /* good */
        }
 }
                return NULL; /* good */
        }
 }


@@ -1068,12 +1071,32 @@ static void execute_commands_non_atomic(struct command *commands,
                                        struct shallow_info *si)
 {
        struct command *cmd;
                                        struct shallow_info *si)
 {
        struct command *cmd;

+       struct strbuf err = STRBUF_INIT;
+

        for (cmd = commands; cmd; cmd = cmd->next) {
                if (!should_process_cmd(cmd))
                        continue;
 
        for (cmd = commands; cmd; cmd = cmd->next) {
                if (!should_process_cmd(cmd))
                        continue;
 

+               transaction = ref_transaction_begin(&err);
+               if (!transaction) {
+                       rp_error("%s", err.buf);
+                       strbuf_reset(&err);
+                       cmd->error_string = "transaction failed to start";
+                       continue;
+               }
+

                cmd->error_string = update(cmd, si);
                cmd->error_string = update(cmd, si);

+
+               if (!cmd->error_string
+                   && ref_transaction_commit(transaction, &err)) {
+                       rp_error("%s", err.buf);
+                       strbuf_reset(&err);
+                       cmd->error_string = "failed to update ref";
+               }
+               ref_transaction_free(transaction);

        }
        }

+
+       strbuf_release(&err);

 }
 
 static void execute_commands(struct command *commands,
 }
 
 static void execute_commands(struct command *commands,