* HEAD and namespaces @ 2019-05-21 2:59 Bryan Turner 2019-05-21 21:46 ` Jeff King 0 siblings, 1 reply; 6+ messages in thread From: Bryan Turner @ 2019-05-21 2:59 UTC (permalink / raw) To: Git Users When using GIT_NAMESPACE, it appears the "symref" added to the capabilities advertisement doesn't get the namespace stripped. The namespace is stripped for the advertised refs, including "HEAD", but not on the "symref". Lafiel:test bturner$ GIT_NAMESPACE=foo GIT_TRACE_PACKET=1 git ls-remote origin 19:51:54.012696 pkt-line.c:80 packet: git< b9acca03606d4c674be8b7e79cd788cedbec957c HEAD\0multi_ack thin-pack side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=refs/namespaces/foo/HEAD:refs/namespaces/foo/refs/heads/master agent=git/2.20.1 19:51:54.013017 pkt-line.c:80 packet: git< b9acca03606d4c674be8b7e79cd788cedbec957c refs/heads/master 19:51:54.013028 pkt-line.c:80 packet: git< 0000 19:51:54.013035 pkt-line.c:80 packet: git> 0000 b9acca03606d4c674be8b7e79cd788cedbec957c HEAD b9acca03606d4c674be8b7e79cd788cedbec957c refs/heads/master I don't know whether the client somehow does some stripping on the "symref" to decide that HEAD should be "refs/namespaces/foo/refs/heads/master", but I'd assume not. Either way, since the clone can't find the HEAD value (either because it doesn't see "refs/namespaces/foo/HEAD" as HEAD, which I'd assume is the case, or because it can't find "refs/namespaces/foo/refs/heads/master"), it falls back on the old behavior of picking the first branch with a matching commit. That brings back all the "wrong branch" issues with cloning that adding "symref" fixed. Is this a bug? An oversight? An intentional decision? How is HEAD supposed to work when using GIT_NAMESPACE? Perhaps the expectation is that namespaces won't have their own HEADs? I'd say perhaps it's that even in the namespace the target ref shouldn't be namespaced, but that doesn't seem like it could possibly be correct since the namespace could contain refs that don't exist outside it, so Git would see the symbolic ref as broken. Any insight would be greatly appreciated! Bryan ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: HEAD and namespaces 2019-05-21 2:59 HEAD and namespaces Bryan Turner @ 2019-05-21 21:46 ` Jeff King 2019-05-22 4:31 ` [PATCH] upload-pack: strip namespace from symref data Jeff King 0 siblings, 1 reply; 6+ messages in thread From: Jeff King @ 2019-05-21 21:46 UTC (permalink / raw) To: Bryan Turner; +Cc: Git Users On Mon, May 20, 2019 at 07:59:03PM -0700, Bryan Turner wrote: > When using GIT_NAMESPACE, it appears the "symref" added to the > capabilities advertisement doesn't get the namespace stripped. The > namespace is stripped for the advertised refs, including "HEAD", but > not on the "symref". > > Lafiel:test bturner$ GIT_NAMESPACE=foo GIT_TRACE_PACKET=1 git ls-remote origin > 19:51:54.012696 pkt-line.c:80 packet: git< > b9acca03606d4c674be8b7e79cd788cedbec957c HEAD\0multi_ack thin-pack > side-band side-band-64k ofs-delta shallow deepen-since deepen-not > deepen-relative no-progress include-tag multi_ack_detailed > symref=refs/namespaces/foo/HEAD:refs/namespaces/foo/refs/heads/master Yeah, that seems totally broken. It's neat that we find HEAD inside the namespace. But I think there are two bugs here: 1. We must call it "HEAD" and not the nonsense refs/namespaces/foo/HEAD 2. We need to similarly remove the namespace from its contents. I suppose it's possible that somebody stores the already-truncated name in the symref, but as you noted then such a symref would be totally broken from the perspective of the non-namespaced repo. > I don't know whether the client somehow does some stripping on the > "symref" to decide that HEAD should be > "refs/namespaces/foo/refs/heads/master", but I'd assume not. I don't think it can. It has no idea that namespaces are in play at all (and the point of the feature is for it to be invisible to the client). > Is this a bug? An oversight? An intentional decision? How is HEAD > supposed to work when using GIT_NAMESPACE? Perhaps the expectation is > that namespaces won't have their own HEADs? I'd say perhaps it's that > even in the namespace the target ref shouldn't be namespaced, but that > doesn't seem like it could possibly be correct since the namespace > could contain refs that don't exist outside it, so Git would see the > symbolic ref as broken. I think it should be doing: diff --git a/upload-pack.c b/upload-pack.c index 24298913c0..4d2129e7fc 100644 --- a/upload-pack.c +++ b/upload-pack.c @@ -1037,8 +1037,8 @@ static int find_symref(const char *refname, const struct object_id *oid, symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag); if (!symref_target || (flag & REF_ISSYMREF) == 0) die("'%s' is a symref but it is not?", refname); - item = string_list_append(cb_data, refname); - item->util = xstrdup(symref_target); + item = string_list_append(cb_data, strip_namespace(refname)); + item->util = xstrdup(strip_namespace(symref_target)); return 0; } and this case has just been broken since 7171d8c15f (upload-pack: send symbolic ref information as capability, 2013-09-17). It mostly works because of fallback to the old guessing behavior, so nobody really noticed. (I also suspect namespaces are not widely used at all, but I could be wrong). -Peff ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH] upload-pack: strip namespace from symref data 2019-05-21 21:46 ` Jeff King @ 2019-05-22 4:31 ` Jeff King 2019-05-22 10:33 ` Ævar Arnfjörð Bjarmason 0 siblings, 1 reply; 6+ messages in thread From: Jeff King @ 2019-05-22 4:31 UTC (permalink / raw) To: Bryan Turner; +Cc: Git Users Since 7171d8c15f (upload-pack: send symbolic ref information as capability, 2013-09-17), we've sent cloning and fetching clients special information about which branch HEAD is pointing to, so that they don't have to guess based on matching up commit ids. However, this feature has never worked properly with the GIT_NAMESPACE feature. Because upload-pack uses head_ref_namespaced(find_symref), we do find and report on refs/namespaces/foo/HEAD instead of the actual HEAD of the repo. This makes sense, since the branch pointed to by the top-level HEAD may not be advertised at all. But we do two things wrong: 1. We report the full name refs/namespaces/foo/HEAD, instead of just HEAD. Meaning no client is going to bother doing anything with that symref, since we're not otherwise advertising it. 2. We report the symref destination using its full name (e.g., refs/namespaces/foo/refs/heads/master). That's similarly useless to the client, who only saw "refs/heads/master" in the advertisement. We should be stripping the namespace prefix off of both places (which this patch fixes). Likely nobody noticed because bug (1) means that from the client's perspective, we did not report on HEAD at all. And thus it uses the pre-7171d8c15f fallback code to guess the correct HEAD, which is usually right. It only falls down in ambiguous cases (like the one laid out in the included test). This also means that we don't have to worry about breaking anybody who was putting pre-stripped names into their namespace symrefs when we fix bug (2). Because of bug (1), nobody would have been using the symref we advertised in the first place (not to mention that those symrefs would have appeared broken for any non-namespaced access). Note that we have separate fixes here for the v0 and v2 protocols. The symref advertisement moved in v2 to be a part of the ls-refs command. This actually gets part (1) right, since the symref annotation piggy-backs on the existing ref advertisement, which is properly stripped. But it still needs a fix for part (2). The included tests cover both protocols. Reported-by: Bryan Turner <bturner@atlassian.com> Signed-off-by: Jeff King <peff@peff.net> --- This is the same as my earlier fix, but with the v2 bit added, and of course tests and a commit message. Thanks (as usual) for a helpful bug report. I don't know if we have a general philosophy for testing v0 versus v2. Without specifying the protocol at all, we'd catch the former on a regular run and the latter under a GIT_TEST_PROTOCOL_VERSION=2 run. So we _could_ just rely on that, but since I had to do two separate fixes, it made sense to me to include explicit tests. ls-refs.c | 3 ++- t/t5509-fetch-push-namespaces.sh | 28 ++++++++++++++++++++++++++++ upload-pack.c | 4 ++-- 3 files changed, 32 insertions(+), 3 deletions(-) diff --git a/ls-refs.c b/ls-refs.c index 0a7dbc6442..818aef70a0 100644 --- a/ls-refs.c +++ b/ls-refs.c @@ -57,7 +57,8 @@ static int send_ref(const char *refname, const struct object_id *oid, if (!symref_target) die("'%s' is a symref but it is not?", refname); - strbuf_addf(&refline, " symref-target:%s", symref_target); + strbuf_addf(&refline, " symref-target:%s", + strip_namespace(symref_target)); } if (data->peel) { diff --git a/t/t5509-fetch-push-namespaces.sh b/t/t5509-fetch-push-namespaces.sh index c88df78c0b..75cbfcc392 100755 --- a/t/t5509-fetch-push-namespaces.sh +++ b/t/t5509-fetch-push-namespaces.sh @@ -124,4 +124,32 @@ test_expect_success 'try to update a hidden full ref' ' test_must_fail git -C original push pushee-namespaced master ' +test_expect_success 'set up ambiguous HEAD' ' + git init ambiguous && + ( + cd ambiguous && + git commit --allow-empty -m foo && + git update-ref refs/namespaces/ns/refs/heads/one HEAD && + git update-ref refs/namespaces/ns/refs/heads/two HEAD && + git symbolic-ref refs/namespaces/ns/HEAD \ + refs/namespaces/ns/refs/heads/two + ) +' + +test_expect_success 'clone chooses correct HEAD (v0)' ' + GIT_NAMESPACE=ns git -c protocol.version=0 \ + clone ambiguous ambiguous-v0 && + echo refs/heads/two >expect && + git -C ambiguous-v0 symbolic-ref HEAD >actual && + test_cmp expect actual +' + +test_expect_success 'clone chooses correct HEAD (v2)' ' + GIT_NAMESPACE=ns git -c protocol.version=2 \ + clone ambiguous ambiguous-v2 && + echo refs/heads/two >expect && + git -C ambiguous-v2 symbolic-ref HEAD >actual && + test_cmp expect actual +' + test_done diff --git a/upload-pack.c b/upload-pack.c index 24298913c0..4d2129e7fc 100644 --- a/upload-pack.c +++ b/upload-pack.c @@ -1037,8 +1037,8 @@ static int find_symref(const char *refname, const struct object_id *oid, symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag); if (!symref_target || (flag & REF_ISSYMREF) == 0) die("'%s' is a symref but it is not?", refname); - item = string_list_append(cb_data, refname); - item->util = xstrdup(symref_target); + item = string_list_append(cb_data, strip_namespace(refname)); + item->util = xstrdup(strip_namespace(symref_target)); return 0; } -- 2.22.0.rc1.539.g7bfcdfe86d ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH] upload-pack: strip namespace from symref data 2019-05-22 4:31 ` [PATCH] upload-pack: strip namespace from symref data Jeff King @ 2019-05-22 10:33 ` Ævar Arnfjörð Bjarmason 2019-05-23 6:11 ` [PATCH v2] " Jeff King 0 siblings, 1 reply; 6+ messages in thread From: Ævar Arnfjörð Bjarmason @ 2019-05-22 10:33 UTC (permalink / raw) To: Jeff King; +Cc: Bryan Turner, Git Users On Wed, May 22 2019, Jeff King wrote: > Since 7171d8c15f (upload-pack: send symbolic ref information as > capability, 2013-09-17), we've sent cloning and fetching clients special > information about which branch HEAD is pointing to, so that they don't > have to guess based on matching up commit ids. I'd add a 2nd paragraph here: The client will then use the corresponding code added in a45b5f0552 ("connect: annotate refs with their symref information in get_remote_head()", 2013-09-17) to find the intended symref. See 9907d1359c ("Merge branch 'jc/upload-pack-send-symref'", 2013-10-30) for the full set of changes related to this. ...because, see later... > However, this feature has never worked properly with the GIT_NAMESPACE > feature. Because upload-pack uses head_ref_namespaced(find_symref), we > do find and report on refs/namespaces/foo/HEAD instead of the actual > HEAD of the repo. This makes sense, since the branch pointed to by the > top-level HEAD may not be advertised at all. But we do two things wrong: > > 1. We report the full name refs/namespaces/foo/HEAD, instead of just > HEAD. Meaning no client is going to bother doing anything with that > symref, since we're not otherwise advertising it. > > 2. We report the symref destination using its full name (e.g., > refs/namespaces/foo/refs/heads/master). That's similarly useless to > the client, who only saw "refs/heads/master" in the advertisement. > > We should be stripping the namespace prefix off of both places (which > this patch fixes). > > Likely nobody noticed because bug (1) means that from the client's > perspective, we did not report on HEAD at all. And thus it uses the > pre-7171d8c15f fallback code to guess the correct HEAD, which is usually > right. It only falls down in ambiguous cases (like the one laid out in > the included test). ...because here you're talking about "the client's perspective" and "it uses the pre-7171d8c15f [...] code", but this should say "the pre-a45b5f0552 code", i.e. mention the commit that changed the *client* logic. Well, the client also "uses" the server-side code indirectly, but I think it's easier to follow along if we note what both sides are (as I dug up when reviewing this...). > This also means that we don't have to worry about breaking anybody who > was putting pre-stripped names into their namespace symrefs when we fix > bug (2). Because of bug (1), nobody would have been using the symref we > advertised in the first place (not to mention that those symrefs would > have appeared broken for any non-namespaced access). > > Note that we have separate fixes here for the v0 and v2 protocols. The > symref advertisement moved in v2 to be a part of the ls-refs command. > This actually gets part (1) right, since the symref annotation > piggy-backs on the existing ref advertisement, which is properly > stripped. But it still needs a fix for part (2). The included tests > cover both protocols. > > Reported-by: Bryan Turner <bturner@atlassian.com> > Signed-off-by: Jeff King <peff@peff.net> > --- > This is the same as my earlier fix, but with the v2 bit added, and of > course tests and a commit message. Thanks (as usual) for a helpful bug > report. > > I don't know if we have a general philosophy for testing v0 versus v2. > Without specifying the protocol at all, we'd catch the former on a > regular run and the latter under a GIT_TEST_PROTOCOL_VERSION=2 run. So > we _could_ just rely on that, but since I had to do two separate fixes, > it made sense to me to include explicit tests. Yeah, we shouldn't rely on the GIT_TEST_* stuff for coverage, it should just be used to find things that fall between the cracks. > ls-refs.c | 3 ++- > t/t5509-fetch-push-namespaces.sh | 28 ++++++++++++++++++++++++++++ > upload-pack.c | 4 ++-- > 3 files changed, 32 insertions(+), 3 deletions(-) > > diff --git a/ls-refs.c b/ls-refs.c > index 0a7dbc6442..818aef70a0 100644 > --- a/ls-refs.c > +++ b/ls-refs.c > @@ -57,7 +57,8 @@ static int send_ref(const char *refname, const struct object_id *oid, > if (!symref_target) > die("'%s' is a symref but it is not?", refname); > > - strbuf_addf(&refline, " symref-target:%s", symref_target); > + strbuf_addf(&refline, " symref-target:%s", > + strip_namespace(symref_target)); > } > > if (data->peel) { > diff --git a/t/t5509-fetch-push-namespaces.sh b/t/t5509-fetch-push-namespaces.sh > index c88df78c0b..75cbfcc392 100755 > --- a/t/t5509-fetch-push-namespaces.sh > +++ b/t/t5509-fetch-push-namespaces.sh > @@ -124,4 +124,32 @@ test_expect_success 'try to update a hidden full ref' ' > test_must_fail git -C original push pushee-namespaced master > ' > > +test_expect_success 'set up ambiguous HEAD' ' > + git init ambiguous && > + ( > + cd ambiguous && > + git commit --allow-empty -m foo && > + git update-ref refs/namespaces/ns/refs/heads/one HEAD && > + git update-ref refs/namespaces/ns/refs/heads/two HEAD && > + git symbolic-ref refs/namespaces/ns/HEAD \ > + refs/namespaces/ns/refs/heads/two > + ) > +' > + > +test_expect_success 'clone chooses correct HEAD (v0)' ' > + GIT_NAMESPACE=ns git -c protocol.version=0 \ > + clone ambiguous ambiguous-v0 && > + echo refs/heads/two >expect && > + git -C ambiguous-v0 symbolic-ref HEAD >actual && > + test_cmp expect actual > +' > + > +test_expect_success 'clone chooses correct HEAD (v2)' ' > + GIT_NAMESPACE=ns git -c protocol.version=2 \ > + clone ambiguous ambiguous-v2 && > + echo refs/heads/two >expect && > + git -C ambiguous-v2 symbolic-ref HEAD >actual && > + test_cmp expect actual > +' > + > test_done > diff --git a/upload-pack.c b/upload-pack.c > index 24298913c0..4d2129e7fc 100644 > --- a/upload-pack.c > +++ b/upload-pack.c > @@ -1037,8 +1037,8 @@ static int find_symref(const char *refname, const struct object_id *oid, > symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag); > if (!symref_target || (flag & REF_ISSYMREF) == 0) > die("'%s' is a symref but it is not?", refname); > - item = string_list_append(cb_data, refname); > - item->util = xstrdup(symref_target); > + item = string_list_append(cb_data, strip_namespace(refname)); > + item->util = xstrdup(strip_namespace(symref_target)); > return 0; > } ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH v2] upload-pack: strip namespace from symref data 2019-05-22 10:33 ` Ævar Arnfjörð Bjarmason @ 2019-05-23 6:11 ` Jeff King 2019-05-28 17:01 ` Junio C Hamano 0 siblings, 1 reply; 6+ messages in thread From: Jeff King @ 2019-05-23 6:11 UTC (permalink / raw) To: Ævar Arnfjörð Bjarmason; +Cc: Bryan Turner, Git Users On Wed, May 22, 2019 at 12:33:56PM +0200, Ævar Arnfjörð Bjarmason wrote: > > Likely nobody noticed because bug (1) means that from the client's > > perspective, we did not report on HEAD at all. And thus it uses the > > pre-7171d8c15f fallback code to guess the correct HEAD, which is usually > > right. It only falls down in ambiguous cases (like the one laid out in > > the included test). > > ...because here you're talking about "the client's perspective" and "it > uses the pre-7171d8c15f [...] code", but this should say "the > pre-a45b5f0552 code", i.e. mention the commit that changed the *client* > logic. Heh. I actually found this split, too, while digging in the history, but thought it might be adding distracting details to the commit message. But hey, if you're gonna read them _carefully_, I guess I can be more precise. ;) The fallback code isn't even from a45b5f0552; it's much older than that. We started looking at ref annotations at all in fbb074c253 (remote: make guess_remote_head() use exact HEAD lookup if it is available, 2009-02-27). The guessing code that falls back to comes from 8434c2f1af (Build in clone, 2008-04-27). I didn't bother finding the true origin in the shell script. ;) So instead of mentioning it at the top (because the bug really is just on the server side), I re-wrote the paragraph about the client a little more clearly and precisely: Likely nobody noticed because we tend to do the right thing anyway. Bug (1) means that we said nothing about HEAD (just refs/namespace/foo/HEAD). And so the client half of the code, from a45b5f0552 (connect: annotate refs with their symref information in get_remote_head(), 2013-09-17), does not annotate HEAD, and we use the fallback in guess_remote_head(), matching refs by object id. Which is usually right. It only falls down in ambiguous cases, like the one laid out in the included test. Revised patch below. -- >8 -- Subject: [PATCH] upload-pack: strip namespace from symref data Since 7171d8c15f (upload-pack: send symbolic ref information as capability, 2013-09-17), we've sent cloning and fetching clients special information about which branch HEAD is pointing to, so that they don't have to guess based on matching up commit ids. However, this feature has never worked properly with the GIT_NAMESPACE feature. Because upload-pack uses head_ref_namespaced(find_symref), we do find and report on refs/namespaces/foo/HEAD instead of the actual HEAD of the repo. This makes sense, since the branch pointed to by the top-level HEAD may not be advertised at all. But we do two things wrong: 1. We report the full name refs/namespaces/foo/HEAD, instead of just HEAD. Meaning no client is going to bother doing anything with that symref, since we're not otherwise advertising it. 2. We report the symref destination using its full name (e.g., refs/namespaces/foo/refs/heads/master). That's similarly useless to the client, who only saw "refs/heads/master" in the advertisement. We should be stripping the namespace prefix off of both places (which this patch fixes). Likely nobody noticed because we tend to do the right thing anyway. Bug (1) means that we said nothing about HEAD (just refs/namespace/foo/HEAD). And so the client half of the code, from a45b5f0552 (connect: annotate refs with their symref information in get_remote_head(), 2013-09-17), does not annotate HEAD, and we use the fallback in guess_remote_head(), matching refs by object id. Which is usually right. It only falls down in ambiguous cases, like the one laid out in the included test. This also means that we don't have to worry about breaking anybody who was putting pre-stripped names into their namespace symrefs when we fix bug (2). Because of bug (1), nobody would have been using the symref we advertised in the first place (not to mention that those symrefs would have appeared broken for any non-namespaced access). Note that we have separate fixes here for the v0 and v2 protocols. The symref advertisement moved in v2 to be a part of the ls-refs command. This actually gets part (1) right, since the symref annotation piggy-backs on the existing ref advertisement, which is properly stripped. But it still needs a fix for part (2). The included tests cover both protocols. Reported-by: Bryan Turner <bturner@atlassian.com> Signed-off-by: Jeff King <peff@peff.net> --- ls-refs.c | 3 ++- t/t5509-fetch-push-namespaces.sh | 28 ++++++++++++++++++++++++++++ upload-pack.c | 4 ++-- 3 files changed, 32 insertions(+), 3 deletions(-) diff --git a/ls-refs.c b/ls-refs.c index 0a7dbc6442..818aef70a0 100644 --- a/ls-refs.c +++ b/ls-refs.c @@ -57,7 +57,8 @@ static int send_ref(const char *refname, const struct object_id *oid, if (!symref_target) die("'%s' is a symref but it is not?", refname); - strbuf_addf(&refline, " symref-target:%s", symref_target); + strbuf_addf(&refline, " symref-target:%s", + strip_namespace(symref_target)); } if (data->peel) { diff --git a/t/t5509-fetch-push-namespaces.sh b/t/t5509-fetch-push-namespaces.sh index c88df78c0b..75cbfcc392 100755 --- a/t/t5509-fetch-push-namespaces.sh +++ b/t/t5509-fetch-push-namespaces.sh @@ -124,4 +124,32 @@ test_expect_success 'try to update a hidden full ref' ' test_must_fail git -C original push pushee-namespaced master ' +test_expect_success 'set up ambiguous HEAD' ' + git init ambiguous && + ( + cd ambiguous && + git commit --allow-empty -m foo && + git update-ref refs/namespaces/ns/refs/heads/one HEAD && + git update-ref refs/namespaces/ns/refs/heads/two HEAD && + git symbolic-ref refs/namespaces/ns/HEAD \ + refs/namespaces/ns/refs/heads/two + ) +' + +test_expect_success 'clone chooses correct HEAD (v0)' ' + GIT_NAMESPACE=ns git -c protocol.version=0 \ + clone ambiguous ambiguous-v0 && + echo refs/heads/two >expect && + git -C ambiguous-v0 symbolic-ref HEAD >actual && + test_cmp expect actual +' + +test_expect_success 'clone chooses correct HEAD (v2)' ' + GIT_NAMESPACE=ns git -c protocol.version=2 \ + clone ambiguous ambiguous-v2 && + echo refs/heads/two >expect && + git -C ambiguous-v2 symbolic-ref HEAD >actual && + test_cmp expect actual +' + test_done diff --git a/upload-pack.c b/upload-pack.c index 24298913c0..4d2129e7fc 100644 --- a/upload-pack.c +++ b/upload-pack.c @@ -1037,8 +1037,8 @@ static int find_symref(const char *refname, const struct object_id *oid, symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag); if (!symref_target || (flag & REF_ISSYMREF) == 0) die("'%s' is a symref but it is not?", refname); - item = string_list_append(cb_data, refname); - item->util = xstrdup(symref_target); + item = string_list_append(cb_data, strip_namespace(refname)); + item->util = xstrdup(strip_namespace(symref_target)); return 0; } -- 2.22.0.rc1.549.gadb183c4cb ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH v2] upload-pack: strip namespace from symref data 2019-05-23 6:11 ` [PATCH v2] " Jeff King @ 2019-05-28 17:01 ` Junio C Hamano 0 siblings, 0 replies; 6+ messages in thread From: Junio C Hamano @ 2019-05-28 17:01 UTC (permalink / raw) To: Jeff King; +Cc: Ævar Arnfjörð Bjarmason, Bryan Turner, Git Users Jeff King <peff@peff.net> writes: > Revised patch below. Thanks. I never took the "separate namespaces" thing as a serious feature, so it is understandable that I ignored it completely when I did 7171d8c15f. The explanation and the code both look good. Thanks. > -- >8 -- > Subject: [PATCH] upload-pack: strip namespace from symref data > > Since 7171d8c15f (upload-pack: send symbolic ref information as > capability, 2013-09-17), we've sent cloning and fetching clients special > information about which branch HEAD is pointing to, so that they don't > have to guess based on matching up commit ids. > > However, this feature has never worked properly with the GIT_NAMESPACE > feature. Because upload-pack uses head_ref_namespaced(find_symref), we > do find and report on refs/namespaces/foo/HEAD instead of the actual > HEAD of the repo. This makes sense, since the branch pointed to by the > top-level HEAD may not be advertised at all. But we do two things wrong: > > 1. We report the full name refs/namespaces/foo/HEAD, instead of just > HEAD. Meaning no client is going to bother doing anything with that > symref, since we're not otherwise advertising it. > > 2. We report the symref destination using its full name (e.g., > refs/namespaces/foo/refs/heads/master). That's similarly useless to > the client, who only saw "refs/heads/master" in the advertisement. > > We should be stripping the namespace prefix off of both places (which > this patch fixes). > > Likely nobody noticed because we tend to do the right thing anyway. Bug > (1) means that we said nothing about HEAD (just refs/namespace/foo/HEAD). > And so the client half of the code, from a45b5f0552 (connect: annotate > refs with their symref information in get_remote_head(), 2013-09-17), > does not annotate HEAD, and we use the fallback in guess_remote_head(), > matching refs by object id. Which is usually right. It only falls down > in ambiguous cases, like the one laid out in the included test. > > This also means that we don't have to worry about breaking anybody who > was putting pre-stripped names into their namespace symrefs when we fix > bug (2). Because of bug (1), nobody would have been using the symref we > advertised in the first place (not to mention that those symrefs would > have appeared broken for any non-namespaced access). > > Note that we have separate fixes here for the v0 and v2 protocols. The > symref advertisement moved in v2 to be a part of the ls-refs command. > This actually gets part (1) right, since the symref annotation > piggy-backs on the existing ref advertisement, which is properly > stripped. But it still needs a fix for part (2). The included tests > cover both protocols. > > Reported-by: Bryan Turner <bturner@atlassian.com> > Signed-off-by: Jeff King <peff@peff.net> > --- > ls-refs.c | 3 ++- > t/t5509-fetch-push-namespaces.sh | 28 ++++++++++++++++++++++++++++ > upload-pack.c | 4 ++-- > 3 files changed, 32 insertions(+), 3 deletions(-) > > diff --git a/ls-refs.c b/ls-refs.c > index 0a7dbc6442..818aef70a0 100644 > --- a/ls-refs.c > +++ b/ls-refs.c > @@ -57,7 +57,8 @@ static int send_ref(const char *refname, const struct object_id *oid, > if (!symref_target) > die("'%s' is a symref but it is not?", refname); > > - strbuf_addf(&refline, " symref-target:%s", symref_target); > + strbuf_addf(&refline, " symref-target:%s", > + strip_namespace(symref_target)); > } > > if (data->peel) { > diff --git a/t/t5509-fetch-push-namespaces.sh b/t/t5509-fetch-push-namespaces.sh > index c88df78c0b..75cbfcc392 100755 > --- a/t/t5509-fetch-push-namespaces.sh > +++ b/t/t5509-fetch-push-namespaces.sh > @@ -124,4 +124,32 @@ test_expect_success 'try to update a hidden full ref' ' > test_must_fail git -C original push pushee-namespaced master > ' > > +test_expect_success 'set up ambiguous HEAD' ' > + git init ambiguous && > + ( > + cd ambiguous && > + git commit --allow-empty -m foo && > + git update-ref refs/namespaces/ns/refs/heads/one HEAD && > + git update-ref refs/namespaces/ns/refs/heads/two HEAD && > + git symbolic-ref refs/namespaces/ns/HEAD \ > + refs/namespaces/ns/refs/heads/two > + ) > +' > + > +test_expect_success 'clone chooses correct HEAD (v0)' ' > + GIT_NAMESPACE=ns git -c protocol.version=0 \ > + clone ambiguous ambiguous-v0 && > + echo refs/heads/two >expect && > + git -C ambiguous-v0 symbolic-ref HEAD >actual && > + test_cmp expect actual > +' > + > +test_expect_success 'clone chooses correct HEAD (v2)' ' > + GIT_NAMESPACE=ns git -c protocol.version=2 \ > + clone ambiguous ambiguous-v2 && > + echo refs/heads/two >expect && > + git -C ambiguous-v2 symbolic-ref HEAD >actual && > + test_cmp expect actual > +' > + > test_done > diff --git a/upload-pack.c b/upload-pack.c > index 24298913c0..4d2129e7fc 100644 > --- a/upload-pack.c > +++ b/upload-pack.c > @@ -1037,8 +1037,8 @@ static int find_symref(const char *refname, const struct object_id *oid, > symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag); > if (!symref_target || (flag & REF_ISSYMREF) == 0) > die("'%s' is a symref but it is not?", refname); > - item = string_list_append(cb_data, refname); > - item->util = xstrdup(symref_target); > + item = string_list_append(cb_data, strip_namespace(refname)); > + item->util = xstrdup(strip_namespace(symref_target)); > return 0; > } ^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2019-05-28 17:01 UTC | newest] Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2019-05-21 2:59 HEAD and namespaces Bryan Turner 2019-05-21 21:46 ` Jeff King 2019-05-22 4:31 ` [PATCH] upload-pack: strip namespace from symref data Jeff King 2019-05-22 10:33 ` Ævar Arnfjörð Bjarmason 2019-05-23 6:11 ` [PATCH v2] " Jeff King 2019-05-28 17:01 ` Junio C Hamano
Code repositories for project(s) associated with this public inbox https://80x24.org/mirrors/git.git This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).