kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

receive-pack.c: use a reference transaction for updating the refs 

Wrap all the ref updates inside a transaction.

In the new API there is no distinction between failure to lock and
failure to write a ref.  Both can be permanent (e.g., a ref
"refs/heads/topic" is blocking creation of the lock file
"refs/heads/topic/1.lock") or transient (e.g., file system full) and
there's no clear difference in how the client should respond, so
replace the two statuses "failed to lock" and "failed to write" with
a single status "failed to update ref".  In both cases a more
detailed message is sent by sideband to diagnose the problem.

Example, before:

 error: there are still refs under 'refs/heads/topic'
 remote: error: failed to lock refs/heads/topic
 To foo
  ! [remote rejected] HEAD -> topic (failed to lock)

After:

 error: there are still refs under 'refs/heads/topic'
 remote: error: Cannot lock the ref 'refs/heads/topic'.
 To foo
  ! [remote rejected] HEAD -> topic (failed to update ref)

Signed-off-by: Ronnie Sahlberg <sahlberg@google.com>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Ronnie Sahlberg 2014-04-28 14:36:15 -07:00 committed by Junio C Hamano
parent b4d75ac1d1
commit 6629ea2d4a
1 changed files with 16 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
builtin/receive-pack.c
View File

@ -475,7 +475,6 @@ static const char *update(struct command *cmd, struct shallow_info *si)
const char *namespaced_name; const char *namespaced_name;
unsigned char *old_sha1 = cmd->old_sha1; unsigned char *old_sha1 = cmd->old_sha1;
unsigned char *new_sha1 = cmd->new_sha1; unsigned char *new_sha1 = cmd->new_sha1;
struct ref_lock *lock;


/* only refs/... are allowed */ /* only refs/... are allowed */
if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) { if (!starts_with(name, "refs/") || check_refname_format(name + 5, 0)) {
@ -576,19 +575,27 @@ static const char *update(struct command *cmd, struct shallow_info *si)
return NULL; /* good */ return NULL; /* good */
} }
else { else {
struct strbuf err = STRBUF_INIT;
struct ref_transaction *transaction;

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


lock = lock_any_ref_for_update(namespaced_name, old_sha1, transaction = ref_transaction_begin(&err);
0, NULL); if (!transaction ||
if (!lock) { ref_transaction_update(transaction, namespaced_name,
rp_error("failed to lock %s", name); new_sha1, old_sha1, 0, 1, &err) ||
return "failed to lock"; ref_transaction_commit(transaction, "push", &err)) {
} ref_transaction_free(transaction);
if (write_ref_sha1(lock, new_sha1, "push")) {
return "failed to write"; /* error() already called */ rp_error("%s", err.buf);
strbuf_release(&err);
return "failed to update ref";
} }

ref_transaction_free(transaction);
strbuf_release(&err);
return NULL; /* good */ return NULL; /* good */
} }
} }