See my comment to your cover letter where I suggest using ref
transactions instead of making callers deal with even more of the
details of updating references.  But I will comment on these patches
anyway, in case you'd rather leave them closer to the current form.

On 04/14/2014 08:29 PM, Ronnie Sahlberg wrote:
> Change the function write_ref_sha1() to just write the ref but not
> commit the ref or the lockfile.
> Add a new function commit_ref_lock() that will commit the change done by
> a previous write_ref_sha1().
> Update all callers of write_ref_sha1() to call commit_ref_lock().
> 
> The new pattern for updating a ref is now :
> 
> lock = lock_ref_sha1_basic() (or varient of)

s/varient/variant/

> write_ref_sha1(lock)
> unlock_ref(lock) | commit_ref_lock(lock)
> 
> Once write_ref_sha1() returns, the new ref has been written and the lock
> file has been closed.
> At that stage we can then either call unlock_ref() which will abort the
> update and delete the lock file withouth applying it, or call

You need a comma after "unlock_ref()".

s/withouth/without/

> commit_ref_lock() which will rename the lock file onto the ref file.


The commit message would be easier to read with better formatting; maybe

---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---
refs.c: split writing and commiting a ref into two separate functions

* Change the function write_ref_sha1() to just write the ref but not
  commit the ref or the lockfile.

* Add a new function commit_ref_lock() that will commit the change done by
  a previous write_ref_sha1().

* Update all callers of write_ref_sha1() to call commit_ref_lock().

The new pattern for updating a ref is now :

    lock = lock_ref_sha1_basic() (or variant of)
    write_ref_sha1(lock)
    unlock_ref(lock) | commit_ref_lock(lock)

Once write_ref_sha1() returns, the new ref has been written and the lock
file has been closed. At that stage we can then either call unlock_ref(),
which will abort the update and delete the lock file without applying it,
or call commit_ref_lock() which will rename the lock file onto the ref
file.

Signed-off-by: Ronnie Sahlberg <sahlb...@google.com>
---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---8<---


> Signed-off-by: Ronnie Sahlberg <sahlb...@google.com>
> ---
>  branch.c               | 10 ++++++++--
>  builtin/commit.c       |  5 +++++
>  builtin/fetch.c        |  7 ++++++-
>  builtin/receive-pack.c |  4 ++++
>  builtin/replace.c      |  6 +++++-
>  builtin/tag.c          |  6 +++++-
>  fast-import.c          | 18 ++++++++++++++++--
>  refs.c                 | 41 +++++++++++++++++++++++++++++++----------
>  refs.h                 |  4 ++++
>  sequencer.c            |  4 ++++
>  walker.c               |  4 ++++
>  11 files changed, 92 insertions(+), 17 deletions(-)
> 
> diff --git a/branch.c b/branch.c
> index 660097b..903ea75 100644
> --- a/branch.c
> +++ b/branch.c
> @@ -304,9 +304,15 @@ void create_branch(const char *head,
>       if (real_ref && track)
>               setup_tracking(ref.buf + 11, real_ref, track, quiet);
>  
> -     if (!dont_change_ref)
> -             if (write_ref_sha1(lock, sha1, msg) < 0)
> +     if (!dont_change_ref) {
> +             if (write_ref_sha1(lock, sha1, msg) < 0) {
> +                     unlock_ref(lock);
>                       die_errno(_("Failed to write ref"));
> +             }
> +             if (commit_ref_lock(lock) < 0) {
> +                     die_errno(_("Failed to commit ref"));
> +             }
> +     }
>  
>       strbuf_release(&ref);
>       free(real_ref);

There are a lot of changes like this with similar duplicated error
handling.  Why not define a helper function like
write_ref_sha1_and_commit() that does what the old write_ref_sha1() used
to do (for the callers who don't care about updating multiple references
at once)?

In fact, I would recommend renaming the function in a preparatory
commit, to reduce the amount of code churn in the second commit where
you extract the two new separate functions.

> diff --git a/builtin/commit.c b/builtin/commit.c
> index d9550c5..3d8a3a8 100644
> --- a/builtin/commit.c
> +++ b/builtin/commit.c
> @@ -1686,9 +1686,14 @@ int cmd_commit(int argc, const char **argv, const char 
> *prefix)
>               die(_("cannot lock HEAD ref"));
>       }
>       if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
> +             unlock_ref(ref_lock);
>               rollback_index_files();
>               die(_("cannot update HEAD ref"));
>       }
> +     if (commit_ref_lock(ref_lock) < 0) {
> +             rollback_index_files();
> +             die(_("cannot commit HEAD ref"));
> +     }
>  
>       unlink(git_path("CHERRY_PICK_HEAD"));
>       unlink(git_path("REVERT_HEAD"));
> diff --git a/builtin/fetch.c b/builtin/fetch.c
> index 55f457c..ebfb854 100644
> --- a/builtin/fetch.c
> +++ b/builtin/fetch.c
> @@ -388,7 +388,12 @@ static int s_update_ref(const char *action,
>       if (!lock)
>               return errno == ENOTDIR ? STORE_REF_ERROR_DF_CONFLICT :
>                                         STORE_REF_ERROR_OTHER;
> -     if (write_ref_sha1(lock, ref->new_sha1, msg) < 0)
> +     if (write_ref_sha1(lock, ref->new_sha1, msg) < 0) {
> +             unlock_ref(lock);
> +             return errno == ENOTDIR ? STORE_REF_ERROR_DF_CONFLICT :
> +                                       STORE_REF_ERROR_OTHER;
> +     }
> +     if (commit_ref_lock(lock) < 0)
>               return errno == ENOTDIR ? STORE_REF_ERROR_DF_CONFLICT :
>                                         STORE_REF_ERROR_OTHER;
>       return 0;
> diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
> index c323081..4760274 100644
> --- a/builtin/receive-pack.c
> +++ b/builtin/receive-pack.c
> @@ -587,8 +587,12 @@ static const char *update(struct command *cmd, struct 
> shallow_info *si)
>                       return "failed to lock";
>               }
>               if (write_ref_sha1(lock, new_sha1, "push")) {
> +                     unlock_ref(lock);
>                       return "failed to write"; /* error() already called */
>               }
> +             if (commit_ref_lock(lock))
> +                     return "failed to commit"; /* error() already called */
> +
>               return NULL; /* good */
>       }
>  }
> diff --git a/builtin/replace.c b/builtin/replace.c
> index b62420a..c09ff49 100644
> --- a/builtin/replace.c
> +++ b/builtin/replace.c
> @@ -160,8 +160,12 @@ static int replace_object(const char *object_ref, const 
> char *replace_ref,
>       lock = lock_any_ref_for_update(ref, prev, 0, NULL);
>       if (!lock)
>               die("%s: cannot lock the ref", ref);
> -     if (write_ref_sha1(lock, repl, NULL) < 0)
> +     if (write_ref_sha1(lock, repl, NULL) < 0) {
> +             unlock_ref(lock);
>               die("%s: cannot update the ref", ref);
> +     }
> +     if (commit_ref_lock(lock) < 0)
> +             die("%s: cannot commit the ref", ref);
>  
>       return 0;
>  }
> diff --git a/builtin/tag.c b/builtin/tag.c
> index 40356e3..8653a64 100644
> --- a/builtin/tag.c
> +++ b/builtin/tag.c
> @@ -644,8 +644,12 @@ int cmd_tag(int argc, const char **argv, const char 
> *prefix)
>       lock = lock_any_ref_for_update(ref.buf, prev, 0, NULL);
>       if (!lock)
>               die(_("%s: cannot lock the ref"), ref.buf);
> -     if (write_ref_sha1(lock, object, NULL) < 0)
> +     if (write_ref_sha1(lock, object, NULL) < 0) {
> +             unlock_ref(lock);
>               die(_("%s: cannot update the ref"), ref.buf);
> +     }
> +     if (commit_ref_lock(lock) < 0)
> +             die(_("%s: cannot commit the ref"), ref.buf);
>       if (force && !is_null_sha1(prev) && hashcmp(prev, object))
>               printf(_("Updated tag '%s' (was %s)\n"), tag, 
> find_unique_abbrev(prev, DEFAULT_ABBREV));
>  
> diff --git a/fast-import.c b/fast-import.c
> index fb4738d..f732bfb 100644
> --- a/fast-import.c
> +++ b/fast-import.c
> @@ -1706,8 +1706,13 @@ static int update_branch(struct branch *b)
>                       return -1;
>               }
>       }
> -     if (write_ref_sha1(lock, b->sha1, msg) < 0)
> +     if (write_ref_sha1(lock, b->sha1, msg) < 0) {
> +             unlock_ref(lock);
>               return error("Unable to update %s", b->name);
> +     }
> +     if (commit_ref_lock(lock) < 0) {
> +             return error("Unable to commit %s", b->name);
> +     }
>       return 0;
>  }
>  
> @@ -1732,8 +1737,17 @@ static void dump_tags(void)
>       for (t = first_tag; t; t = t->next_tag) {
>               sprintf(ref_name, "tags/%s", t->name);
>               lock = lock_ref_sha1(ref_name, NULL);
> -             if (!lock || write_ref_sha1(lock, t->sha1, msg) < 0)
> +             if (!lock) {
> +                     failure |= error("Unable to lock %s", ref_name);
> +                     continue;
> +             }
> +             if (write_ref_sha1(lock, t->sha1, msg) < 0) {
>                       failure |= error("Unable to update %s", ref_name);
> +                     unlock_ref(lock);
> +                     continue;
> +             }
> +             if (commit_ref_lock(lock) < 0)
> +                     failure |= error("Unable to commit %s", ref_name);
>       }
>  }
>  
> diff --git a/refs.c b/refs.c
> index 728a761..646afd7 100644
> --- a/refs.c
> +++ b/refs.c
> @@ -2633,9 +2633,14 @@ int rename_ref(const char *oldrefname, const char 
> *newrefname, const char *logms
>       lock->force_write = 1;
>       hashcpy(lock->old_sha1, orig_sha1);
>       if (write_ref_sha1(lock, orig_sha1, logmsg)) {
> +             unlock_ref(lock);
>               error("unable to write current sha1 into %s", newrefname);
>               goto rollback;
>       }
> +     if (commit_ref_lock(lock)) {
> +             error("unable to commit current sha1 into %s", newrefname);
> +             goto rollback;
> +     }
>  
>       return 0;
>  
> @@ -2649,8 +2654,12 @@ int rename_ref(const char *oldrefname, const char 
> *newrefname, const char *logms
>       lock->force_write = 1;
>       flag = log_all_ref_updates;
>       log_all_ref_updates = 0;
> -     if (write_ref_sha1(lock, orig_sha1, NULL))
> +     if (write_ref_sha1(lock, orig_sha1, NULL)) {
> +             unlock_ref(lock);
>               error("unable to write current sha1 into %s", oldrefname);
> +     }
> +     if (commit_ref_lock(lock))
> +             error("unable to commit current sha1 into %s", oldrefname);
>       log_all_ref_updates = flag;
>  
>   rollbacklog:
> @@ -2807,34 +2816,30 @@ int write_ref_sha1(struct ref_lock *lock,
>       if (!lock)
>               return -1;
>       if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
> -             unlock_ref(lock);
> +             lock->skipped_write = 1;
>               return 0;
>       }
>       o = parse_object(sha1);
>       if (!o) {
>               error("Trying to write ref %s with nonexistent object %s",
>                       lock->ref_name, sha1_to_hex(sha1));
> -             unlock_ref(lock);
>               return -1;
>       }
>       if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
>               error("Trying to write non-commit object %s to branch %s",
>                       sha1_to_hex(sha1), lock->ref_name);
> -             unlock_ref(lock);
>               return -1;
>       }
>       if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
>           write_in_full(lock->lock_fd, &term, 1) != 1
>               || close_ref(lock) < 0) {
>               error("Couldn't write %s", lock->lk->filename);
> -             unlock_ref(lock);
>               return -1;
>       }
>       clear_loose_ref_cache(&ref_cache);
>       if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
>           (strcmp(lock->ref_name, lock->orig_ref_name) &&
>            log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 
> 0)) {
> -             unlock_ref(lock);
>               return -1;
>       }
>       if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
> @@ -2858,7 +2863,12 @@ int write_ref_sha1(struct ref_lock *lock,
>                   !strcmp(head_ref, lock->ref_name))
>                       log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
>       }
> -     if (commit_ref(lock)) {
> +     return 0;
> +}
> +
> +int commit_ref_lock(struct ref_lock *lock)
> +{
> +     if (!lock->skipped_write && commit_ref(lock)) {
>               error("Couldn't set %s", lock->ref_name);
>               unlock_ref(lock);
>               return -1;
> @@ -3375,10 +3385,17 @@ int update_ref(const char *action, const char 
> *refname,
>              int flags, enum action_on_err onerr)
>  {
>       struct ref_lock *lock;
> +     int ret;
> +
>       lock = update_ref_lock(refname, oldval, flags, NULL, onerr);
>       if (!lock)
>               return 1;
> -     return update_ref_write(action, refname, sha1, lock, onerr);
> +     ret = update_ref_write(action, refname, sha1, lock, onerr);
> +     if (ret)
> +             unlock_ref(lock);
> +     else
> +             ret = commit_ref_lock(lock);
> +     return ret;
>  }
>  
>  static int ref_update_compare(const void *r1, const void *r2)
> @@ -3453,7 +3470,11 @@ int ref_transaction_commit(struct ref_transaction 
> *transaction,
>                                              update->refname,
>                                              update->new_sha1,
>                                              update->lock, onerr);
> -                     update->lock = NULL; /* freed by update_ref_write */
> +                     if (ret)
> +                             unlock_ref(update->lock);
> +                     else
> +                             commit_ref_lock(update->lock);
> +                     update->lock = NULL;
>                       if (ret)
>                               goto cleanup;
>               }
> @@ -3464,7 +3485,7 @@ int ref_transaction_commit(struct ref_transaction 
> *transaction,
>               struct ref_update *update = updates[i];
>  
>               if (update->lock) {
> -                     delnames[delnum++] = update->lock->ref_name;
> +                     delnames[delnum++] = update->refname;

Isn't this hunk orthogonal to the main point of this commit?  If so,
please split it into a separate commit.

>                       ret |= delete_ref_loose(update->lock, update->type);
>               }
>       }
> diff --git a/refs.h b/refs.h
> index 0f08def..f14a417 100644
> --- a/refs.h
> +++ b/refs.h
> @@ -8,6 +8,7 @@ struct ref_lock {
>       unsigned char old_sha1[20];
>       int lock_fd;
>       int force_write;
> +     int skipped_write;
>  };
>  
>  struct ref_transaction;
> @@ -153,6 +154,9 @@ extern void unlock_ref(struct ref_lock *lock);
>  /** Writes sha1 into the ref specified by the lock. **/
>  extern int write_ref_sha1(struct ref_lock *lock, const unsigned char *sha1, 
> const char *msg);
>  
> +/** Commit any changes done to the ref specified by the lock. **/
> +extern int commit_ref_lock(struct ref_lock *lock);
> +
>  /** Setup reflog before using. **/
>  int log_ref_setup(const char *refname, char *logfile, int bufsize);
>  
> diff --git a/sequencer.c b/sequencer.c
> index bde5f04..ffadf82 100644
> --- a/sequencer.c
> +++ b/sequencer.c
> @@ -283,6 +283,10 @@ static int fast_forward_to(const unsigned char *to, 
> const unsigned char *from,
>                                          0, NULL);
>       strbuf_addf(&sb, "%s: fast-forward", action_name(opts));
>       ret = write_ref_sha1(ref_lock, to, sb.buf);
> +     if (ret)
> +             unlock_ref(ref_lock);
> +     else
> +             ret |= commit_ref_lock(ref_lock);

"|=" could be changed to "=" here and in the next hunk.

>       strbuf_release(&sb);
>       return ret;
>  }
> diff --git a/walker.c b/walker.c
> index 1dd86b8..5ce5a1d 100644
> --- a/walker.c
> +++ b/walker.c
> @@ -295,6 +295,10 @@ int walker_fetch(struct walker *walker, int targets, 
> char **target,
>               if (!write_ref || !write_ref[i])
>                       continue;
>               ret = write_ref_sha1(lock[i], &sha1[20 * i], msg ? msg : "fetch 
> (unknown)");
> +             if (ret)
> +                     unlock_ref(lock[i]);
> +             else
> +                     ret |= commit_ref_lock(lock[i]);
>               lock[i] = NULL;
>               if (ret)
>                       goto unlock_and_fail;
> 


-- 
Michael Haggerty
mhag...@alum.mit.edu
http://softwareswirl.blogspot.com/
--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to