This adds -d flag to update-ref to allow safe deletion of ref.
Before deleting it, the command checks if the given <oldvalue>
still matches the value the caller thought the ref contained.
Similarly, it also accepts 0{40} as <oldvalue> to allow safe
creation of a new ref.
Signed-off-by: Junio C Hamano <junkio@xxxxxxx>
---
Documentation/git-update-ref.txt | 9 ++++++--
builtin-update-ref.c | 16 +++++++++++++--
cache.h | 1 +
refs.c | 41 +++++++++++++++++++++++++++++++++++++-
4 files changed, 62 insertions(+), 5 deletions(-)
diff --git a/Documentation/git-update-ref.txt b/Documentation/git-update-ref.txt
index e062030..723906d 100644
--- a/Documentation/git-update-ref.txt
+++ b/Documentation/git-update-ref.txt
@@ -7,7 +7,7 @@ git-update-ref - update the object name
SYNOPSIS
--------
-'git-update-ref' [-m <reason>] <ref> <newvalue> [<oldvalue>]
+'git-update-ref' [-m <reason>] (-d <ref> <oldvalue> | <ref> <newvalue> [<oldvalue>])
DESCRIPTION
-----------
@@ -20,7 +20,8 @@ possibly dereferencing the symbolic refs
the current value of the <ref> matches <oldvalue>.
E.g. `git-update-ref refs/heads/master <newvalue> <oldvalue>`
updates the master branch head to <newvalue> only if its current
-value is <oldvalue>.
+value is <oldvalue>. You can specify 40 "0" as <oldvalue> to
+make sure that the ref you are creating does not exist.
It also allows a "ref" file to be a symbolic pointer to another
ref file by starting with the four-byte header sequence of
@@ -49,6 +50,10 @@ for reading but not for writing (so we'l
ref symlink to some other tree, if you have copied a whole
archive by creating a symlink tree).
+With `-d` flag, it deletes the named <ref> after verifying it
+still contains <oldvalue>.
+
+
Logging Updates
---------------
If config parameter "core.logAllRefUpdates" is true or the file
diff --git a/builtin-update-ref.c b/builtin-update-ref.c
index ab52833..486b8f2 100644
--- a/builtin-update-ref.c
+++ b/builtin-update-ref.c
@@ -3,15 +3,16 @@ #include "refs.h"
#include "builtin.h"
static const char git_update_ref_usage[] =
-"git-update-ref <refname> <value> [<oldval>] [-m <reason>]";
+"git-update-ref [-m <reason>] (-d <refname> <value> | <refname> <value> [<oldval>])";
int cmd_update_ref(int argc, const char **argv, const char *prefix)
{
const char *refname=NULL, *value=NULL, *oldval=NULL, *msg=NULL;
struct ref_lock *lock;
unsigned char sha1[20], oldsha1[20];
- int i;
+ int i, delete;
+ delete = 0;
setup_ident();
git_config(git_default_config);
@@ -26,6 +27,10 @@ int cmd_update_ref(int argc, const char
die("Refusing to perform update with \\n in message.");
continue;
}
+ if (!strcmp("-d", argv[i])) {
+ delete = 1;
+ continue;
+ }
if (!refname) {
refname = argv[i];
continue;
@@ -44,6 +49,13 @@ int cmd_update_ref(int argc, const char
if (get_sha1(value, sha1))
die("%s: not a valid SHA1", value);
+
+ if (delete) {
+ if (oldval)
+ usage(git_update_ref_usage);
+ return delete_ref(refname, sha1);
+ }
+
hashclr(oldsha1);
if (oldval && get_sha1(oldval, oldsha1))
die("%s: not a valid old SHA1", oldval);
diff --git a/cache.h b/cache.h
index 97debd0..851f4c0 100644
--- a/cache.h
+++ b/cache.h
@@ -179,6 +179,7 @@ struct lock_file {
extern int hold_lock_file_for_update(struct lock_file *, const char *path, int);
extern int commit_lock_file(struct lock_file *);
extern void rollback_lock_file(struct lock_file *);
+extern int delete_ref(const char *, unsigned char *sha1);
/* Environment bits from configuration mechanism */
extern int use_legacy_headers;
diff --git a/refs.c b/refs.c
index b4f6d4f..4d499b0 100644
--- a/refs.c
+++ b/refs.c
@@ -212,6 +212,32 @@ int get_ref_sha1(const char *ref, unsign
return read_ref(git_path("refs/%s", ref), sha1);
}
+int delete_ref(const char *refname, unsigned char *sha1)
+{
+ struct ref_lock *lock;
+ int err, i, ret = 0;
+
+ lock = lock_any_ref_for_update(refname, sha1);
+ if (!lock)
+ return 1;
+ i = strlen(lock->lk->filename) - 5; /* .lock */
+ lock->lk->filename[i] = 0;
+ err = unlink(lock->lk->filename);
+ if (err) {
+ ret = 1;
+ error("unlink(%s) failed: %s",
+ lock->lk->filename, strerror(errno));
+ }
+ lock->lk->filename[i] = '.';
+
+ err = unlink(lock->log_file);
+ if (err && errno != ENOENT)
+ fprintf(stderr, "warning: unlink(%s) failed: %s",
+ lock->log_file, strerror(errno));
+
+ return ret;
+}
+
/*
* Make sure "ref" is something reasonable to have under ".git/refs/";
* We do not like it if:
@@ -268,6 +294,19 @@ static struct ref_lock *verify_lock(stru
{
char buf[40];
int nr, fd = open(lock->ref_file, O_RDONLY);
+
+ if (is_null_sha1(old_sha1)) {
+ /* we wanted to make sure it did not exist */
+ if (fd < 0 && errno == ENOENT)
+ return lock;
+ if (0 <= fd) {
+ close(fd);
+ error("ref %s should be absent but it exists",
+ lock->ref_file);
+ unlock_ref(lock);
+ return NULL;
+ }
+ }
if (fd < 0 && errno != ENOENT) {
error("Can't verify ref %s", lock->ref_file);
unlock_ref(lock);
@@ -296,7 +335,7 @@ static struct ref_lock *lock_ref_sha1_ba
const char *orig_path = path;
struct ref_lock *lock;
struct stat st;
- int mustexist = 0;
+ int mustexist = old_sha1 && !is_null_sha1(old_sha1);
lock = xcalloc(1, sizeof(struct ref_lock));
lock->lock_fd = -1;
--
1.4.2.1.g7a39b
-
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html