pack-refs: add fully-peeled trait

Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.

The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.

The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.

Instead, we add a "fully-peeled" trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.

[commit message and tests by Jeff King <peff@peff.net>]

Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/pack-refs.c b/pack-refs.c
index ebde7850550aea027957a7ec93f904c616f769c9..4461f71a37bea5d935409761cc8a838bff443439 100644 (file)
--- a/pack-refs.c
+++ b/pack-refs.c
@@ -128,7 +128,7 @@ int pack_refs(unsigned int flags)
                die_errno("unable to create ref-pack file structure");
 
        /* perhaps other traits later as well */
                die_errno("unable to create ref-pack file structure");
 
        /* perhaps other traits later as well */

-       fprintf(cbdata.refs_file, "# pack-refs with: peeled \n");
+       fprintf(cbdata.refs_file, "# pack-refs with: peeled fully-peeled \n");

 
        for_each_ref(handle_one_ref, &cbdata);
        if (ferror(cbdata.refs_file))
 
        for_each_ref(handle_one_ref, &cbdata);
        if (ferror(cbdata.refs_file))

diff --git a/refs.c b/refs.c
index da74a2b29a20a2c94fef61641e35980007c1ab95..f5d954c27e8994b60a9f7d937700693db8b51221 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -804,11 +804,38 @@ static const char *parse_ref_line(char *line, unsigned char *sha1)
        return line;
 }
 
        return line;
 }
 

+/*
+ * Read f, which is a packed-refs file, into dir.
+ *
+ * A comment line of the form "# pack-refs with: " may contain zero or
+ * more traits. We interpret the traits as follows:
+ *
+ *   No traits:
+ *
+ *      Probably no references are peeled. But if the file contains a
+ *      peeled value for a reference, we will use it.
+ *
+ *   peeled:
+ *
+ *      References under "refs/tags/", if they *can* be peeled, *are*
+ *      peeled in this file. References outside of "refs/tags/" are
+ *      probably not peeled even if they could have been, but if we find
+ *      a peeled value for such a reference we will use it.
+ *
+ *   fully-peeled:
+ *
+ *      All references in the file that can be peeled are peeled.
+ *      Inversely (and this is more important), any references in the
+ *      file for which no peeled value is recorded is not peelable. This
+ *      trait should typically be written alongside "peeled" for
+ *      compatibility with older clients, but we do not require it
+ *      (i.e., "peeled" is a no-op if "fully-peeled" is set).
+ */

 static void read_packed_refs(FILE *f, struct ref_dir *dir)
 {
        struct ref_entry *last = NULL;
        char refline[PATH_MAX];
 static void read_packed_refs(FILE *f, struct ref_dir *dir)
 {
        struct ref_entry *last = NULL;
        char refline[PATH_MAX];

-       int flag = REF_ISPACKED;
+       enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;

 
        while (fgets(refline, sizeof(refline), f)) {
                unsigned char sha1[20];
 
        while (fgets(refline, sizeof(refline), f)) {
                unsigned char sha1[20];


@@ -817,15 +844,20 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir)
 
                if (!strncmp(refline, header, sizeof(header)-1)) {
                        const char *traits = refline + sizeof(header) - 1;
 
                if (!strncmp(refline, header, sizeof(header)-1)) {
                        const char *traits = refline + sizeof(header) - 1;

-                       if (strstr(traits, " peeled "))
-                               flag |= REF_KNOWS_PEELED;
+                       if (strstr(traits, " fully-peeled "))
+                               peeled = PEELED_FULLY;
+                       else if (strstr(traits, " peeled "))
+                               peeled = PEELED_TAGS;

                        /* perhaps other traits later as well */
                        continue;
                }
 
                refname = parse_ref_line(refline, sha1);
                if (refname) {
                        /* perhaps other traits later as well */
                        continue;
                }
 
                refname = parse_ref_line(refline, sha1);
                if (refname) {

-                       last = create_ref_entry(refname, sha1, flag, 1);
+                       last = create_ref_entry(refname, sha1, REF_ISPACKED, 1);
+                       if (peeled == PEELED_FULLY ||
+                           (peeled == PEELED_TAGS && !prefixcmp(refname, "refs/tags/")))
+                               last->flag |= REF_KNOWS_PEELED;

                        add_ref(dir, last);
                        continue;
                }
                        add_ref(dir, last);
                        continue;
                }


@@ -833,8 +865,15 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir)
                    refline[0] == '^' &&
                    strlen(refline) == 42 &&
                    refline[41] == '\n' &&
                    refline[0] == '^' &&
                    strlen(refline) == 42 &&
                    refline[41] == '\n' &&

-                   !get_sha1_hex(refline + 1, sha1))
+                   !get_sha1_hex(refline + 1, sha1)) {

                        hashcpy(last->u.value.peeled, sha1);
                        hashcpy(last->u.value.peeled, sha1);

+                       /*
+                        * Regardless of what the file header said,
+                        * we definitely know the value of *this*
+                        * reference:
+                        */
+                       last->flag |= REF_KNOWS_PEELED;
+               }

        }
 }
 
        }
 }
 

diff --git a/t/t3211-peel-ref.sh b/t/t3211-peel-ref.sh
index 85f09be9f422e343fb0ee1e8541882448e2e22a7..d4d7792eae845096f8f89ef4d31171d55dac5659 100755 (executable)
--- a/t/t3211-peel-ref.sh
+++ b/t/t3211-peel-ref.sh
@@ -39,4 +39,26 @@ test_expect_success 'refs are peeled outside of refs/tags (packed)' '
        test_cmp expect actual
 '
 
        test_cmp expect actual
 '
 

+test_expect_success 'create old-style pack-refs without fully-peeled' '
+       # Git no longer writes without fully-peeled, so we just write our own
+       # from scratch; we could also munge the existing file to remove the
+       # fully-peeled bits, but that seems even more prone to failure,
+       # especially if the format ever changes again. At least this way we
+       # know we are emulating exactly what an older git would have written.
+       {
+               echo "# pack-refs with: peeled " &&
+               print_ref "refs/heads/master" &&
+               print_ref "refs/outside/foo" &&
+               print_ref "refs/tags/base" &&
+               print_ref "refs/tags/foo" &&
+               echo "^$(git rev-parse "refs/tags/foo^{}")"
+       } >tmp &&
+       mv tmp .git/packed-refs
+'
+
+test_expect_success 'refs are peeled outside of refs/tags (old packed)' '
+       git show-ref -d >actual &&
+       test_cmp expect actual
+'
+

 test_done
 test_done