refs: add option core.logAllRefUpdates = always

When core.logallrefupdates is true, we only create a new reflog for refs
that are under certain well-known hierarchies. The reason is that we
know that some hierarchies (like refs/tags) are not meant to change, and
that unknown hierarchies might not want reflogs at all (e.g., a
hypothetical refs/foo might be meant to change often and drop old
history immediately).

However, sometimes it is useful to override this decision and simply log
for all refs, because the safety and audit trail is more important than
the performance implications of keeping the log around.

This patch introduces a new "always" mode for the core.logallrefupdates
option which will log updates to everything under refs/, regardless
where in the hierarchy it is (we still will not log things like
ORIG_HEAD and FETCH_HEAD, which are known to be transient).

Based-on-patch-by: Jeff King <peff@peff.net>
Signed-off-by: Cornelius Weig <cornelius.weig@tngtech.com>
Reviewed-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/Documentation/config.txt b/Documentation/config.txt
index c7d8a0108344cfcfc0475f9d88518bc53ccfd855..d1fab67ca6ef72e42c0f06360509bf26224dbd27 100644 (file)
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -521,6 +521,8 @@ core.logAllRefUpdates::
        file is automatically created for branch heads (i.e. under
        `refs/heads/`), remote refs (i.e. under `refs/remotes/`),
        note refs (i.e. under `refs/notes/`), and the symbolic ref `HEAD`.
        file is automatically created for branch heads (i.e. under
        `refs/heads/`), remote refs (i.e. under `refs/remotes/`),
        note refs (i.e. under `refs/notes/`), and the symbolic ref `HEAD`.

+       If it is set to `always`, then a missing reflog is automatically
+       created for any ref under `refs/`.

 +
 This information can be used to determine what commit
 was the tip of a branch "2 days ago".
 +
 This information can be used to determine what commit
 was the tip of a branch "2 days ago".

diff --git a/Documentation/git-tag.txt b/Documentation/git-tag.txt
index 5055a9682393409c1ed07e1e417015f46e46a5bc..2ac25a9bb3c1a62903c4c3a11a673db2b984fa1e 100644 (file)
--- a/Documentation/git-tag.txt
+++ b/Documentation/git-tag.txt
@@ -150,7 +150,8 @@ This option is only applicable when listing tags without annotation lines.
        'strip' removes both whitespace and commentary.
 
 --create-reflog::
        'strip' removes both whitespace and commentary.
 
 --create-reflog::

-       Create a reflog for the tag.
+       Create a reflog for the tag. To globally enable reflogs for tags, see
+       `core.logAllRefUpdates` in linkgit:git-config[1].

 
 <tagname>::
        The name of the tag to create, delete, or describe.
 
 <tagname>::
        The name of the tag to create, delete, or describe.

diff --git a/branch.c b/branch.c
index c431cbf6a9f08dedc791317cc1a357730bdf3515..b955d4f316c799f7788896806302bfd4dbcf3ec4 100644 (file)
--- a/branch.c
+++ b/branch.c
@@ -298,7 +298,7 @@ void create_branch(const char *name, const char *start_name,
                         start_name);
 
        if (reflog)
                         start_name);
 
        if (reflog)

-               log_all_ref_updates = 1;
+               log_all_ref_updates = LOG_REFS_NORMAL;

 
        if (!dont_change_ref) {
                struct ref_transaction *transaction;
 
        if (!dont_change_ref) {
                struct ref_transaction *transaction;

diff --git a/builtin/checkout.c b/builtin/checkout.c
index bfe685c198cd38b59ffe66fa6b3d3a7bced60824..569912c3ab9051c5e5a40d3625c194c23d769993 100644 (file)
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -612,22 +612,25 @@ static void update_refs_for_switch(const struct checkout_opts *opts,
        const char *old_desc, *reflog_msg;
        if (opts->new_branch) {
                if (opts->new_orphan_branch) {
        const char *old_desc, *reflog_msg;
        if (opts->new_branch) {
                if (opts->new_orphan_branch) {

-                       if (opts->new_branch_log && !log_all_ref_updates) {
+                       char *refname;
+
+                       refname = mkpathdup("refs/heads/%s", opts->new_orphan_branch);
+                       if (opts->new_branch_log &&
+                           !should_autocreate_reflog(refname)) {

                                int ret;
                                int ret;

-                               char *refname;

                                struct strbuf err = STRBUF_INIT;
 
                                struct strbuf err = STRBUF_INIT;
 

-                               refname = mkpathdup("refs/heads/%s", opts->new_orphan_branch);

                                ret = safe_create_reflog(refname, 1, &err);
                                ret = safe_create_reflog(refname, 1, &err);

-                               free(refname);

                                if (ret) {
                                        fprintf(stderr, _("Can not do reflog for '%s': %s\n"),
                                                opts->new_orphan_branch, err.buf);
                                        strbuf_release(&err);
                                if (ret) {
                                        fprintf(stderr, _("Can not do reflog for '%s': %s\n"),
                                                opts->new_orphan_branch, err.buf);
                                        strbuf_release(&err);

+                                       free(refname);

                                        return;
                                }
                                strbuf_release(&err);
                        }
                                        return;
                                }
                                strbuf_release(&err);
                        }

+                       free(refname);

                }
                else
                        create_branch(opts->new_branch, new->name,
                }
                else
                        create_branch(opts->new_branch, new->name,

diff --git a/builtin/init-db.c b/builtin/init-db.c
index 76d68fad001083d85800b937798529a1682959c9..1d4d6a0078919636dfc0ffefa2aec1699a9827f1 100644 (file)
--- a/builtin/init-db.c
+++ b/builtin/init-db.c
@@ -262,7 +262,7 @@ static int create_default_files(const char *template_path,
                const char *work_tree = get_git_work_tree();
                git_config_set("core.bare", "false");
                /* allow template config file to override the default */
                const char *work_tree = get_git_work_tree();
                git_config_set("core.bare", "false");
                /* allow template config file to override the default */

-               if (log_all_ref_updates == -1)
+               if (log_all_ref_updates == LOG_REFS_UNSET)

                        git_config_set("core.logallrefupdates", "true");
                if (needs_work_tree_config(original_git_dir, work_tree))
                        git_config_set("core.worktree", work_tree);
                        git_config_set("core.logallrefupdates", "true");
                if (needs_work_tree_config(original_git_dir, work_tree))
                        git_config_set("core.worktree", work_tree);

diff --git a/cache.h b/cache.h
index 00a029af3657d319b7df987a36979a519c2dda94..96eeaaf7fb22ccd9b3d565b351f2b6478b1df4a5 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -660,7 +660,6 @@ extern int minimum_abbrev, default_abbrev;
 extern int ignore_case;
 extern int assume_unchanged;
 extern int prefer_symlink_refs;
 extern int ignore_case;
 extern int assume_unchanged;
 extern int prefer_symlink_refs;

-extern int log_all_ref_updates;

 extern int warn_ambiguous_refs;
 extern int warn_on_object_refname_ambiguity;
 extern const char *apply_default_whitespace;
 extern int warn_ambiguous_refs;
 extern int warn_on_object_refname_ambiguity;
 extern const char *apply_default_whitespace;


@@ -728,6 +727,14 @@ enum hide_dotfiles_type {
 };
 extern enum hide_dotfiles_type hide_dotfiles;
 
 };
 extern enum hide_dotfiles_type hide_dotfiles;
 

+enum log_refs_config {
+       LOG_REFS_UNSET = -1,
+       LOG_REFS_NONE = 0,
+       LOG_REFS_NORMAL,
+       LOG_REFS_ALWAYS
+};
+extern enum log_refs_config log_all_ref_updates;
+

 enum branch_track {
        BRANCH_TRACK_UNSPECIFIED = -1,
        BRANCH_TRACK_NEVER = 0,
 enum branch_track {
        BRANCH_TRACK_UNSPECIFIED = -1,
        BRANCH_TRACK_NEVER = 0,

diff --git a/config.c b/config.c
index b680f79732aa867d39a2e10ac889b5b2abfb1e7f..c6b874a7bf763851b425d526f704966aaad129b2 100644 (file)
--- a/config.c
+++ b/config.c
@@ -826,7 +826,12 @@ static int git_default_core_config(const char *var, const char *value)
        }
 
        if (!strcmp(var, "core.logallrefupdates")) {
        }
 
        if (!strcmp(var, "core.logallrefupdates")) {

-               log_all_ref_updates = git_config_bool(var, value);
+               if (value && !strcasecmp(value, "always"))
+                       log_all_ref_updates = LOG_REFS_ALWAYS;
+               else if (git_config_bool(var, value))
+                       log_all_ref_updates = LOG_REFS_NORMAL;
+               else
+                       log_all_ref_updates = LOG_REFS_NONE;

                return 0;
        }
 
                return 0;
        }
 

diff --git a/environment.c b/environment.c
index 8a83101d04240b1b5b1471e68c810f822f68269d..c07fb17fb70bdb3cdf3ae9ab23196af9a0b7ad1b 100644 (file)
--- a/environment.c
+++ b/environment.c
@@ -21,7 +21,6 @@ int ignore_case;
 int assume_unchanged;
 int prefer_symlink_refs;
 int is_bare_repository_cfg = -1; /* unspecified */
 int assume_unchanged;
 int prefer_symlink_refs;
 int is_bare_repository_cfg = -1; /* unspecified */

-int log_all_ref_updates = -1; /* unspecified */

 int warn_ambiguous_refs = 1;
 int warn_on_object_refname_ambiguity = 1;
 int ref_paranoia = -1;
 int warn_ambiguous_refs = 1;
 int warn_on_object_refname_ambiguity = 1;
 int ref_paranoia = -1;


@@ -64,6 +63,7 @@ int merge_log_config = -1;
 int precomposed_unicode = -1; /* see probe_utf8_pathname_composition() */
 unsigned long pack_size_limit_cfg;
 enum hide_dotfiles_type hide_dotfiles = HIDE_DOTFILES_DOTGITONLY;
 int precomposed_unicode = -1; /* see probe_utf8_pathname_composition() */
 unsigned long pack_size_limit_cfg;
 enum hide_dotfiles_type hide_dotfiles = HIDE_DOTFILES_DOTGITONLY;

+enum log_refs_config log_all_ref_updates = LOG_REFS_UNSET;

 
 #ifndef PROTECT_HFS_DEFAULT
 #define PROTECT_HFS_DEFAULT 0
 
 #ifndef PROTECT_HFS_DEFAULT
 #define PROTECT_HFS_DEFAULT 0

diff --git a/refs.c b/refs.c
index 9bd0bc177bb8298148577ce0c3e52134452d6e51..cd36b64ed93f821936fd7ffb68e60ce384119898 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -638,12 +638,17 @@ int copy_reflog_msg(char *buf, const char *msg)
 
 int should_autocreate_reflog(const char *refname)
 {
 
 int should_autocreate_reflog(const char *refname)
 {

-       if (!log_all_ref_updates)
+       switch (log_all_ref_updates) {
+       case LOG_REFS_ALWAYS:
+               return 1;
+       case LOG_REFS_NORMAL:
+               return starts_with(refname, "refs/heads/") ||
+                       starts_with(refname, "refs/remotes/") ||
+                       starts_with(refname, "refs/notes/") ||
+                       !strcmp(refname, "HEAD");
+       default:

                return 0;
                return 0;

-       return starts_with(refname, "refs/heads/") ||
-               starts_with(refname, "refs/remotes/") ||
-               starts_with(refname, "refs/notes/") ||
-               !strcmp(refname, "HEAD");
+       }

 }
 
 int is_branch(const char *refname)
 }
 
 int is_branch(const char *refname)

diff --git a/refs.h b/refs.h
index 69478439137d64f6dab7f20d4f157f6c7a982ac2..9fbff90e79bfc45fada65651cd01765b17376249 100644 (file)
--- a/refs.h
+++ b/refs.h
@@ -64,6 +64,8 @@ int read_ref(const char *refname, unsigned char *sha1);
 
 int ref_exists(const char *refname);
 
 
 int ref_exists(const char *refname);
 

+int should_autocreate_reflog(const char *refname);
+

 int is_branch(const char *refname);
 
 extern int refs_init_db(struct strbuf *err);
 int is_branch(const char *refname);
 
 extern int refs_init_db(struct strbuf *err);

diff --git a/refs/files-backend.c b/refs/files-backend.c
index f9023939d5884e0f975d5997336313695e407ca1..14b17a63f855a203a34dc8ce78ae11beadf77e61 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -2682,7 +2682,7 @@ static int files_rename_ref(struct ref_store *ref_store,
        }
 
        flag = log_all_ref_updates;
        }
 
        flag = log_all_ref_updates;

-       log_all_ref_updates = 0;
+       log_all_ref_updates = LOG_REFS_NONE;

        if (write_ref_to_lockfile(lock, orig_sha1, &err) ||
            commit_ref_update(refs, lock, orig_sha1, NULL, &err)) {
                error("unable to write current sha1 into %s: %s", oldrefname, err.buf);
        if (write_ref_to_lockfile(lock, orig_sha1, &err) ||
            commit_ref_update(refs, lock, orig_sha1, NULL, &err)) {
                error("unable to write current sha1 into %s: %s", oldrefname, err.buf);


@@ -2835,8 +2835,8 @@ static int log_ref_write_1(const char *refname, const unsigned char *old_sha1,
 {
        int logfd, result, oflags = O_APPEND | O_WRONLY;
 
 {
        int logfd, result, oflags = O_APPEND | O_WRONLY;
 

-       if (log_all_ref_updates < 0)
-               log_all_ref_updates = !is_bare_repository();
+       if (log_all_ref_updates == LOG_REFS_UNSET)
+               log_all_ref_updates = is_bare_repository() ? LOG_REFS_NONE : LOG_REFS_NORMAL;

 
        result = log_ref_setup(refname, logfile, err, flags & REF_FORCE_CREATE_REFLOG);
 
 
        result = log_ref_setup(refname, logfile, err, flags & REF_FORCE_CREATE_REFLOG);
 

diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index 708b26082aebcc4c0f9c215db4c96dce15beec67..25444cf5b0f6448e4a1ada56d48f09ab3017a759 100644 (file)
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -133,8 +133,6 @@ int verify_refname_available(const char *newname,
  */
 int copy_reflog_msg(char *buf, const char *msg);
 
  */
 int copy_reflog_msg(char *buf, const char *msg);
 

-int should_autocreate_reflog(const char *refname);
-

 /**
  * Information needed for a single ref update. Set new_sha1 to the new
  * value or to null_sha1 to delete the ref. To check the old value
 /**
  * Information needed for a single ref update. Set new_sha1 to the new
  * value or to null_sha1 to delete the ref. To check the old value

diff --git a/t/t1400-update-ref.sh b/t/t1400-update-ref.sh
index d4fb9770600df75d3162ffbc6c567b1ae152fccd..b9084cacb256d3717a06256eff73daf4ea9aad38 100755 (executable)
--- a/t/t1400-update-ref.sh
+++ b/t/t1400-update-ref.sh
@@ -93,6 +93,42 @@ test_expect_success 'update-ref creates reflogs with --create-reflog' '
        git reflog exists $outside
 '
 
        git reflog exists $outside
 '
 

+test_expect_success 'core.logAllRefUpdates=true does not create reflog by default' '
+       test_config core.logAllRefUpdates true &&
+       test_when_finished "git update-ref -d $outside" &&
+       git update-ref $outside $A &&
+       git rev-parse $A >expect &&
+       git rev-parse $outside >actual &&
+       test_cmp expect actual &&
+       test_must_fail git reflog exists $outside
+'
+
+test_expect_success 'core.logAllRefUpdates=always creates reflog by default' '
+       test_config core.logAllRefUpdates always &&
+       test_when_finished "git update-ref -d $outside" &&
+       git update-ref $outside $A &&
+       git rev-parse $A >expect &&
+       git rev-parse $outside >actual &&
+       test_cmp expect actual &&
+       git reflog exists $outside
+'
+
+test_expect_success 'core.logAllRefUpdates=always creates no reflog for ORIG_HEAD' '
+       test_config core.logAllRefUpdates always &&
+       git update-ref ORIG_HEAD $A &&
+       test_must_fail git reflog exists ORIG_HEAD
+'
+
+test_expect_success '--no-create-reflog overrides core.logAllRefUpdates=always' '
+       test_config core.logAllRefUpdates true &&
+       test_when_finished "git update-ref -d $outside" &&
+       git update-ref --no-create-reflog $outside $A &&
+       git rev-parse $A >expect &&
+       git rev-parse $outside >actual &&
+       test_cmp expect actual &&
+       test_must_fail git reflog exists $outside
+'
+

 test_expect_success \
        "create $m (by HEAD)" \
        "git update-ref HEAD $A &&
 test_expect_success \
        "create $m (by HEAD)" \
        "git update-ref HEAD $A &&


@@ -501,6 +537,7 @@ test_expect_success 'stdin does not create reflogs by default' '
 '
 
 test_expect_success 'stdin creates reflogs with --create-reflog' '
 '
 
 test_expect_success 'stdin creates reflogs with --create-reflog' '

+       test_when_finished "git update-ref -d $outside" &&

        echo "create $outside $m" >stdin &&
        git update-ref --create-reflog --stdin <stdin &&
        git rev-parse $m >expect &&
        echo "create $outside $m" >stdin &&
        git update-ref --create-reflog --stdin <stdin &&
        git rev-parse $m >expect &&

diff --git a/t/t7004-tag.sh b/t/t7004-tag.sh
index 1cfa8a21d23173e51e95906c00342fa13b85d955..1bf622de23cd7ee70a15d32c696ed31dcc799718 100755 (executable)
--- a/t/t7004-tag.sh
+++ b/t/t7004-tag.sh
@@ -71,6 +71,7 @@ test_expect_success 'creating a tag for an unknown revision should fail' '
 
 # commit used in the tests, test_tick is also called here to freeze the date:
 test_expect_success 'creating a tag using default HEAD should succeed' '
 
 # commit used in the tests, test_tick is also called here to freeze the date:
 test_expect_success 'creating a tag using default HEAD should succeed' '

+       test_config core.logAllRefUpdates true &&

        test_tick &&
        echo foo >foo &&
        git add foo &&
        test_tick &&
        echo foo >foo &&
        git add foo &&


@@ -90,6 +91,13 @@ test_expect_success '--create-reflog does not create reflog on failure' '
        test_must_fail git reflog exists refs/tags/mytag
 '
 
        test_must_fail git reflog exists refs/tags/mytag
 '
 

+test_expect_success 'option core.logAllRefUpdates=always creates reflog' '
+       test_when_finished "git tag -d tag_with_reflog" &&
+       test_config core.logAllRefUpdates always &&
+       git tag tag_with_reflog &&
+       git reflog exists refs/tags/tag_with_reflog
+'
+

 test_expect_success 'listing all tags if one exists should succeed' '
        git tag -l &&
        git tag
 test_expect_success 'listing all tags if one exists should succeed' '
        git tag -l &&
        git tag