From c976d415e5352886f0650f8e2edba81866c38587 Mon Sep 17 00:00:00 2001 From: Lars Hjemli Date: Tue, 28 Nov 2006 15:47:40 +0100 Subject: git-branch: add options and tests for branch renaming Extend git-branch with the following options: git-branch -m|-M [] newbranch The -M variation is required to force renaming over an exsisting branchname. This also indroduces $GIT_DIR/RENAME_REF which is a "metabranch" used when renaming branches. It will always hold the original sha1 for the latest renamed branch. Additionally, if $GIT_DIR/logs/RENAME_REF exists, all branch rename events are logged there. Finally, some testcases are added to verify the new options. Signed-off-by: Lars Hjemli Signed-off-by: Junio C Hamano --- refs.c | 169 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 146 insertions(+), 23 deletions(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 96ea8b6907..cdedb45f00 100644 --- a/refs.c +++ b/refs.c @@ -610,6 +610,29 @@ static int remove_empty_directories(char *file) return remove_empty_dir_recursive(path, len); } +static int is_refname_available(const char *ref, const char *oldref, + struct ref_list *list, int quiet) +{ + int namlen = strlen(ref); /* e.g. 'foo/bar' */ + while (list) { + /* list->name could be 'foo' or 'foo/bar/baz' */ + if (!oldref || strcmp(oldref, list->name)) { + int len = strlen(list->name); + int cmplen = (namlen < len) ? namlen : len; + const char *lead = (namlen < len) ? list->name : ref; + if (!strncmp(ref, list->name, cmplen) && + lead[cmplen] == '/') { + if (!quiet) + error("'%s' exists; cannot create '%s'", + list->name, ref); + return 0; + } + } + list = list->next; + } + return 1; +} + static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char *old_sha1, int *flag) { char *ref_file; @@ -643,29 +666,14 @@ static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char orig_ref, strerror(errno)); goto error_return; } - if (is_null_sha1(lock->old_sha1)) { - /* The ref did not exist and we are creating it. - * Make sure there is no existing ref that is packed - * whose name begins with our refname, nor a ref whose - * name is a proper prefix of our refname. - */ - int namlen = strlen(ref); /* e.g. 'foo/bar' */ - struct ref_list *list = get_packed_refs(); - while (list) { - /* list->name could be 'foo' or 'foo/bar/baz' */ - int len = strlen(list->name); - int cmplen = (namlen < len) ? namlen : len; - const char *lead = (namlen < len) ? list->name : ref; - - if (!strncmp(ref, list->name, cmplen) && - lead[cmplen] == '/') { - error("'%s' exists; cannot create '%s'", - list->name, ref); - goto error_return; - } - list = list->next; - } - } + /* When the ref did not exist and we are creating it, + * make sure there is no existing ref that is packed + * whose name begins with our refname, nor a ref whose + * name is a proper prefix of our refname. + */ + if (is_null_sha1(lock->old_sha1) && + !is_refname_available(ref, NULL, get_packed_refs(), 0)) + goto error_return; lock->lk = xcalloc(1, sizeof(struct lock_file)); @@ -776,6 +784,121 @@ int delete_ref(const char *refname, unsigned char *sha1) return ret; } +int rename_ref(const char *oldref, const char *newref) +{ + static const char renamed_ref[] = "RENAMED-REF"; + unsigned char sha1[20], orig_sha1[20]; + int flag = 0, logmoved = 0; + struct ref_lock *lock; + char msg[PATH_MAX*2 + 100]; + struct stat loginfo; + int log = !stat(git_path("logs/%s", oldref), &loginfo); + + if (S_ISLNK(loginfo.st_mode)) + return error("reflog for %s is a symlink", oldref); + + if (!resolve_ref(oldref, orig_sha1, 1, &flag)) + return error("refname %s not found", oldref); + + if (!is_refname_available(newref, oldref, get_packed_refs(), 0)) + return 1; + + if (!is_refname_available(newref, oldref, get_loose_refs(), 0)) + return 1; + + if (snprintf(msg, sizeof(msg), "renamed %s to %s", oldref, newref) > sizeof(msg)) + return error("Refnames to long"); + + lock = lock_ref_sha1_basic(renamed_ref, NULL, NULL); + if (!lock) + return error("unable to lock %s", renamed_ref); + lock->force_write = 1; + if (write_ref_sha1(lock, orig_sha1, msg)) + return error("unable to save current sha1 in %s", renamed_ref); + + if (log && rename(git_path("logs/%s", oldref), git_path("tmp-renamed-log"))) + return error("unable to move logfile logs/%s to tmp-renamed-log: %s", + oldref, strerror(errno)); + + if (delete_ref(oldref, orig_sha1)) { + error("unable to delete old %s", oldref); + goto rollback; + } + + if (resolve_ref(newref, sha1, 1, &flag) && delete_ref(newref, sha1)) { + if (errno==EISDIR) { + if (remove_empty_directories(git_path("%s", newref))) { + error("Directory not empty: %s", newref); + goto rollback; + } + } else { + error("unable to delete existing %s", newref); + goto rollback; + } + } + + if (log && safe_create_leading_directories(git_path("logs/%s", newref))) { + error("unable to create directory for %s", newref); + goto rollback; + } + + retry: + if (log && rename(git_path("tmp-renamed-log"), git_path("logs/%s", newref))) { + if (errno==EISDIR) { + if (remove_empty_directories(git_path("logs/%s", newref))) { + error("Directory not empty: logs/%s", newref); + goto rollback; + } + goto retry; + } else { + error("unable to move logfile tmp-renamed-log to logs/%s: %s", + newref, strerror(errno)); + goto rollback; + } + } + logmoved = log; + + lock = lock_ref_sha1_basic(newref, NULL, NULL); + if (!lock) { + error("unable to lock %s for update", newref); + goto rollback; + } + + lock->force_write = 1; + hashcpy(lock->old_sha1, orig_sha1); + if (write_ref_sha1(lock, orig_sha1, msg)) { + error("unable to write current sha1 into %s", newref); + goto rollback; + } + + return 0; + + rollback: + lock = lock_ref_sha1_basic(oldref, NULL, NULL); + if (!lock) { + error("unable to lock %s for rollback", oldref); + goto rollbacklog; + } + + lock->force_write = 1; + flag = log_all_ref_updates; + log_all_ref_updates = 0; + if (write_ref_sha1(lock, orig_sha1, NULL)) + error("unable to write current sha1 into %s", oldref); + log_all_ref_updates = flag; + + rollbacklog: + if (logmoved && rename(git_path("logs/%s", newref), git_path("logs/%s", oldref))) + error("unable to restore logfile %s from %s: %s", + oldref, newref, strerror(errno)); + if (!logmoved && log && + rename(git_path("tmp-renamed-log"), git_path("logs/%s", oldref))) + error("unable to restore logfile %s from tmp-renamed-log: %s", + oldref, strerror(errno)); + + return 1; +} + void unlock_ref(struct ref_lock *lock) { if (lock->lock_fd >= 0) { -- cgit v1.3 From 16c2bfbb449a90db00a46984d7dd7f735caa1d56 Mon Sep 17 00:00:00 2001 From: Lars Hjemli Date: Wed, 29 Nov 2006 21:44:56 +0100 Subject: rename_ref: use lstat(2) when testing for symlink The current check for symlinked reflogs was based on stat(2), which is utterly embarrassing. Fix it, and add a matching testcase. Signed-off-by: Lars Hjemli Signed-off-by: Junio C Hamano --- refs.c | 2 +- t/t3200-branch.sh | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index cdedb45f00..c23561e158 100644 --- a/refs.c +++ b/refs.c @@ -792,7 +792,7 @@ int rename_ref(const char *oldref, const char *newref) struct ref_lock *lock; char msg[PATH_MAX*2 + 100]; struct stat loginfo; - int log = !stat(git_path("logs/%s", oldref), &loginfo); + int log = !lstat(git_path("logs/%s", oldref), &loginfo); if (S_ISLNK(loginfo.st_mode)) return error("reflog for %s is a symlink", oldref); diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh index afaa8536a9..5782c30b03 100755 --- a/t/t3200-branch.sh +++ b/t/t3200-branch.sh @@ -104,4 +104,11 @@ test_expect_success \ git-branch -m s/s s && test -f .git/logs/refs/heads/s' +test_expect_failure \ + 'git-branch -m u v should fail when the reflog for u is a symlink' \ + 'git-branch -l u && + mv .git/logs/refs/heads/u real-u && + ln -s real-u .git/logs/refs/heads/u && + git-branch -m u v' + test_done -- cgit v1.3 From 678d0f4cbfa7a3b529c6e894f2977bef6a2d3e4c Mon Sep 17 00:00:00 2001 From: Lars Hjemli Date: Thu, 30 Nov 2006 03:16:56 +0100 Subject: git-branch: let caller specify logmsg This changes the signature of rename_ref() in refs.[hc] to include a logmessage for the reflogs. Also, builtin-branch.c is modified to provide a proper logmessage + call setup_ident() before any logmessages are written. Signed-off-by: Lars Hjemli Signed-off-by: Junio C Hamano --- builtin-branch.c | 8 ++++++-- refs.c | 10 +++------- refs.h | 2 +- 3 files changed, 10 insertions(+), 10 deletions(-) (limited to 'refs.c') diff --git a/builtin-branch.c b/builtin-branch.c index 153682601e..3fc6f84773 100644 --- a/builtin-branch.c +++ b/builtin-branch.c @@ -247,7 +247,7 @@ static void create_branch(const char *name, const char *start, static void rename_branch(const char *oldname, const char *newname, int force) { - char oldref[PATH_MAX], newref[PATH_MAX]; + char oldref[PATH_MAX], newref[PATH_MAX], logmsg[PATH_MAX*2 + 100]; unsigned char sha1[20]; if (snprintf(oldref, sizeof(oldref), "refs/heads/%s", oldname) > sizeof(oldref)) @@ -265,7 +265,10 @@ static void rename_branch(const char *oldname, const char *newname, int force) if (resolve_ref(newref, sha1, 1, NULL) && !force) die("A branch named '%s' already exists.", newname); - if (rename_ref(oldref, newref)) + snprintf(logmsg, sizeof(logmsg), "Branch: renamed %s to %s", + oldref, newref); + + if (rename_ref(oldref, newref, logmsg)) die("Branch rename failed"); if (!strcmp(oldname, head) && create_symref("HEAD", newref)) @@ -281,6 +284,7 @@ int cmd_branch(int argc, const char **argv, const char *prefix) int kinds = REF_LOCAL_BRANCH; int i; + setup_ident(); git_config(git_default_config); for (i = 1; i < argc; i++) { diff --git a/refs.c b/refs.c index c23561e158..2ac8273ea4 100644 --- a/refs.c +++ b/refs.c @@ -784,13 +784,12 @@ int delete_ref(const char *refname, unsigned char *sha1) return ret; } -int rename_ref(const char *oldref, const char *newref) +int rename_ref(const char *oldref, const char *newref, const char *logmsg) { static const char renamed_ref[] = "RENAMED-REF"; unsigned char sha1[20], orig_sha1[20]; int flag = 0, logmoved = 0; struct ref_lock *lock; - char msg[PATH_MAX*2 + 100]; struct stat loginfo; int log = !lstat(git_path("logs/%s", oldref), &loginfo); @@ -806,14 +805,11 @@ int rename_ref(const char *oldref, const char *newref) if (!is_refname_available(newref, oldref, get_loose_refs(), 0)) return 1; - if (snprintf(msg, sizeof(msg), "renamed %s to %s", oldref, newref) > sizeof(msg)) - return error("Refnames to long"); - lock = lock_ref_sha1_basic(renamed_ref, NULL, NULL); if (!lock) return error("unable to lock %s", renamed_ref); lock->force_write = 1; - if (write_ref_sha1(lock, orig_sha1, msg)) + if (write_ref_sha1(lock, orig_sha1, logmsg)) return error("unable to save current sha1 in %s", renamed_ref); if (log && rename(git_path("logs/%s", oldref), git_path("tmp-renamed-log"))) @@ -866,7 +862,7 @@ int rename_ref(const char *oldref, const char *newref) lock->force_write = 1; hashcpy(lock->old_sha1, orig_sha1); - if (write_ref_sha1(lock, orig_sha1, msg)) { + if (write_ref_sha1(lock, orig_sha1, logmsg)) { error("unable to write current sha1 into %s", newref); goto rollback; } diff --git a/refs.h b/refs.h index ce73d5c7ae..51aab1e6bf 100644 --- a/refs.h +++ b/refs.h @@ -48,6 +48,6 @@ extern int read_ref_at(const char *ref, unsigned long at_time, int cnt, unsigned extern int check_ref_format(const char *target); /** rename ref, return 0 on success **/ -extern int rename_ref(const char *oldref, const char *newref); +extern int rename_ref(const char *oldref, const char *newref, const char *logmsg); #endif /* REFS_H */ -- cgit v1.3