2018-03-15 17:31:21 +00:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
|
|
test_description='test git wire-protocol version 2'
|
|
|
|
|
|
|
|
|
|
TEST_NO_CREATE_REPO=1
|
|
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
tests: mark tests relying on the current default for `init.defaultBranch`
In addition to the manual adjustment to let the `linux-gcc` CI job run
the test suite with `master` and then with `main`, this patch makes sure
that GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME is set in all test scripts
that currently rely on the initial branch name being `master by default.
To determine which test scripts to mark up, the first step was to
force-set the default branch name to `master` in
- all test scripts that contain the keyword `master`,
- t4211, which expects `t/t4211/history.export` with a hard-coded ref to
initialize the default branch,
- t5560 because it sources `t/t556x_common` which uses `master`,
- t8002 and t8012 because both source `t/annotate-tests.sh` which also
uses `master`)
This trick was performed by this command:
$ sed -i '/^ *\. \.\/\(test-lib\|lib-\(bash\|cvs\|git-svn\)\|gitweb-lib\)\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' $(git grep -l master t/t[0-9]*.sh) \
t/t4211*.sh t/t5560*.sh t/t8002*.sh t/t8012*.sh
After that, careful, manual inspection revealed that some of the test
scripts containing the needle `master` do not actually rely on a
specific default branch name: either they mention `master` only in a
comment, or they initialize that branch specificially, or they do not
actually refer to the current default branch. Therefore, the
aforementioned modification was undone in those test scripts thusly:
$ git checkout HEAD -- \
t/t0027-auto-crlf.sh t/t0060-path-utils.sh \
t/t1011-read-tree-sparse-checkout.sh \
t/t1305-config-include.sh t/t1309-early-config.sh \
t/t1402-check-ref-format.sh t/t1450-fsck.sh \
t/t2024-checkout-dwim.sh \
t/t2106-update-index-assume-unchanged.sh \
t/t3040-subprojects-basic.sh t/t3301-notes.sh \
t/t3308-notes-merge.sh t/t3423-rebase-reword.sh \
t/t3436-rebase-more-options.sh \
t/t4015-diff-whitespace.sh t/t4257-am-interactive.sh \
t/t5323-pack-redundant.sh t/t5401-update-hooks.sh \
t/t5511-refspec.sh t/t5526-fetch-submodules.sh \
t/t5529-push-errors.sh t/t5530-upload-pack-error.sh \
t/t5548-push-porcelain.sh \
t/t5552-skipping-fetch-negotiator.sh \
t/t5572-pull-submodule.sh t/t5608-clone-2gb.sh \
t/t5614-clone-submodules-shallow.sh \
t/t7508-status.sh t/t7606-merge-custom.sh \
t/t9302-fast-import-unpack-limit.sh
We excluded one set of test scripts in these commands, though: the range
of `git p4` tests. The reason? `git p4` stores the (foreign) remote
branch in the branch called `p4/master`, which is obviously not the
default branch. Manual analysis revealed that only five of these tests
actually require a specific default branch name to pass; They were
modified thusly:
$ sed -i '/^ *\. \.\/lib-git-p4\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' t/t980[0167]*.sh t/t9811*.sh
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-11-18 23:44:19 +00:00
|
|
|
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
|
|
|
|
|
2018-03-15 17:31:21 +00:00
|
|
|
. ./test-lib.sh
|
|
|
|
|
|
|
|
|
|
# Test protocol v2 with 'git://' transport
|
|
|
|
|
#
|
|
|
|
|
. "$TEST_DIRECTORY"/lib-git-daemon.sh
|
|
|
|
|
start_git_daemon --export-all --enable=receive-pack
|
|
|
|
|
daemon_parent=$GIT_DAEMON_DOCUMENT_ROOT_PATH/parent
|
|
|
|
|
|
|
|
|
|
test_expect_success 'create repo to be served by git-daemon' '
|
|
|
|
|
git init "$daemon_parent" &&
|
|
|
|
|
test_commit -C "$daemon_parent" one
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'list refs with git:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
ls-remote --symref "$GIT_DAEMON_URL/parent" >actual &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
2021-08-23 13:17:49 +00:00
|
|
|
grep "ls-remote> .*\\\0\\\0version=2\\\0$" log &&
|
2018-03-15 17:31:21 +00:00
|
|
|
# Server responded using protocol v2
|
2021-08-23 13:17:49 +00:00
|
|
|
grep "ls-remote< version 2" log &&
|
2018-03-15 17:31:21 +00:00
|
|
|
|
|
|
|
|
git ls-remote --symref "$GIT_DAEMON_URL/parent" >expect &&
|
2018-10-05 21:54:04 +00:00
|
|
|
test_cmp expect actual
|
2018-03-15 17:31:21 +00:00
|
|
|
'
|
|
|
|
|
|
2019-11-05 17:07:25 +00:00
|
|
|
test_expect_success 'ref advertisement is filtered with ls-remote using protocol v2' '
|
2018-03-15 17:31:24 +00:00
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
2020-11-18 23:44:35 +00:00
|
|
|
ls-remote "$GIT_DAEMON_URL/parent" main >actual &&
|
2018-03-15 17:31:24 +00:00
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
2020-11-18 23:44:35 +00:00
|
|
|
$(git -C "$daemon_parent" rev-parse refs/heads/main)$(printf "\t")refs/heads/main
|
2018-03-15 17:31:24 +00:00
|
|
|
EOF
|
|
|
|
|
|
2018-10-05 21:54:04 +00:00
|
|
|
test_cmp expect actual
|
2018-03-15 17:31:24 +00:00
|
|
|
'
|
|
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
test_expect_success 'clone with git:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
clone "$GIT_DAEMON_URL/parent" daemon_child &&
|
|
|
|
|
|
|
|
|
|
git -C daemon_child log -1 --format=%s >actual &&
|
|
|
|
|
git -C "$daemon_parent" log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "clone> .*\\\0\\\0version=2\\\0$" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "clone< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'fetch with git:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_commit -C "$daemon_parent" two &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C daemon_child -c protocol.version=2 \
|
|
|
|
|
fetch &&
|
|
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C daemon_child log -1 --format=%s origin/main >actual &&
|
2018-03-15 17:31:28 +00:00
|
|
|
git -C "$daemon_parent" log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "fetch> .*\\\0\\\0version=2\\\0$" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "fetch< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
2018-09-27 19:24:07 +00:00
|
|
|
test_expect_success 'fetch by hash without tag following with protocol v2 does not list refs' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_commit -C "$daemon_parent" two_a &&
|
|
|
|
|
git -C "$daemon_parent" rev-parse two_a >two_a_hash &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C daemon_child -c protocol.version=2 \
|
|
|
|
|
fetch --no-tags origin $(cat two_a_hash) &&
|
|
|
|
|
|
|
|
|
|
grep "fetch< version 2" log &&
|
|
|
|
|
! grep "fetch> command=ls-refs" log
|
|
|
|
|
'
|
|
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
test_expect_success 'pull with git:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C daemon_child -c protocol.version=2 \
|
|
|
|
|
pull &&
|
|
|
|
|
|
|
|
|
|
git -C daemon_child log -1 --format=%s >actual &&
|
|
|
|
|
git -C "$daemon_parent" log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "fetch> .*\\\0\\\0version=2\\\0$" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "fetch< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
2018-03-15 17:31:31 +00:00
|
|
|
test_expect_success 'push with git:// and a config of v2 does not request v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
# Till v2 for push is designed, make sure that if a client has
|
|
|
|
|
# protocol.version configured to use v2, that the client instead falls
|
|
|
|
|
# back and uses v0.
|
|
|
|
|
|
|
|
|
|
test_commit -C daemon_child three &&
|
|
|
|
|
|
|
|
|
|
# Push to another branch, as the target repository has the
|
2020-11-18 23:44:35 +00:00
|
|
|
# main branch checked out and we cannot push into it.
|
2018-03-15 17:31:31 +00:00
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C daemon_child -c protocol.version=2 \
|
|
|
|
|
push origin HEAD:client_branch &&
|
|
|
|
|
|
|
|
|
|
git -C daemon_child log -1 --format=%s >actual &&
|
|
|
|
|
git -C "$daemon_parent" log -1 --format=%s client_branch >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
! grep "push> .*\\\0\\\0version=2\\\0$" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
! grep "push< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
2018-03-15 17:31:21 +00:00
|
|
|
stop_git_daemon
|
|
|
|
|
|
|
|
|
|
# Test protocol v2 with 'file://' transport
|
|
|
|
|
#
|
|
|
|
|
test_expect_success 'create repo to be served by file:// transport' '
|
|
|
|
|
git init file_parent &&
|
|
|
|
|
test_commit -C file_parent one
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'list refs with file:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
ls-remote --symref "file://$(pwd)/file_parent" >actual &&
|
|
|
|
|
|
|
|
|
|
# Server responded using protocol v2
|
2021-08-23 13:17:49 +00:00
|
|
|
grep "ls-remote< version 2" log &&
|
2018-03-15 17:31:21 +00:00
|
|
|
|
|
|
|
|
git ls-remote --symref "file://$(pwd)/file_parent" >expect &&
|
2018-10-05 21:54:04 +00:00
|
|
|
test_cmp expect actual
|
2018-03-15 17:31:21 +00:00
|
|
|
'
|
|
|
|
|
|
2019-11-05 17:07:25 +00:00
|
|
|
test_expect_success 'ref advertisement is filtered with ls-remote using protocol v2' '
|
2018-03-15 17:31:24 +00:00
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
2020-11-18 23:44:35 +00:00
|
|
|
ls-remote "file://$(pwd)/file_parent" main >actual &&
|
2018-03-15 17:31:24 +00:00
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
2020-11-18 23:44:35 +00:00
|
|
|
$(git -C file_parent rev-parse refs/heads/main)$(printf "\t")refs/heads/main
|
2018-03-15 17:31:24 +00:00
|
|
|
EOF
|
|
|
|
|
|
2018-10-05 21:54:04 +00:00
|
|
|
test_cmp expect actual
|
2018-03-15 17:31:24 +00:00
|
|
|
'
|
|
|
|
|
|
2018-04-23 22:46:23 +00:00
|
|
|
test_expect_success 'server-options are sent when using ls-remote' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
2020-11-18 23:44:35 +00:00
|
|
|
ls-remote -o hello -o world "file://$(pwd)/file_parent" main >actual &&
|
2018-04-23 22:46:23 +00:00
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
2020-11-18 23:44:35 +00:00
|
|
|
$(git -C file_parent rev-parse refs/heads/main)$(printf "\t")refs/heads/main
|
2018-04-23 22:46:23 +00:00
|
|
|
EOF
|
|
|
|
|
|
2018-10-05 21:54:04 +00:00
|
|
|
test_cmp expect actual &&
|
2018-04-23 22:46:23 +00:00
|
|
|
grep "server-option=hello" log &&
|
|
|
|
|
grep "server-option=world" log
|
|
|
|
|
'
|
|
|
|
|
|
2019-04-12 19:51:21 +00:00
|
|
|
test_expect_success 'warn if using server-option with ls-remote with legacy protocol' '
|
|
|
|
|
test_must_fail env GIT_TEST_PROTOCOL_VERSION=0 git -c protocol.version=0 \
|
2020-11-18 23:44:35 +00:00
|
|
|
ls-remote -o hello -o world "file://$(pwd)/file_parent" main 2>err &&
|
2019-04-12 19:51:21 +00:00
|
|
|
|
|
|
|
|
test_i18ngrep "see protocol.version in" err &&
|
|
|
|
|
test_i18ngrep "server options require protocol version 2 or later" err
|
|
|
|
|
'
|
2018-04-23 22:46:23 +00:00
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
test_expect_success 'clone with file:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
clone "file://$(pwd)/file_parent" file_child &&
|
|
|
|
|
|
|
|
|
|
git -C file_child log -1 --format=%s >actual &&
|
|
|
|
|
git -C file_parent log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Server responded using protocol v2
|
2018-07-20 22:07:54 +00:00
|
|
|
grep "clone< version 2" log &&
|
|
|
|
|
|
|
|
|
|
# Client sent ref-prefixes to filter the ref-advertisement
|
|
|
|
|
grep "ref-prefix HEAD" log &&
|
|
|
|
|
grep "ref-prefix refs/heads/" log &&
|
|
|
|
|
grep "ref-prefix refs/tags/" log
|
2018-03-15 17:31:28 +00:00
|
|
|
'
|
|
|
|
|
|
2021-02-05 20:48:49 +00:00
|
|
|
test_expect_success 'clone of empty repo propagates name of default branch' '
|
|
|
|
|
test_when_finished "rm -rf file_empty_parent file_empty_child" &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=mydefaultbranch init file_empty_parent &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=main -c protocol.version=2 \
|
|
|
|
|
clone "file://$(pwd)/file_empty_parent" file_empty_child &&
|
|
|
|
|
grep "refs/heads/mydefaultbranch" file_empty_child/.git/HEAD
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success '...but not if explicitly forbidden by config' '
|
|
|
|
|
test_when_finished "rm -rf file_empty_parent file_empty_child" &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=mydefaultbranch init file_empty_parent &&
|
|
|
|
|
test_config -C file_empty_parent lsrefs.unborn ignore &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=main -c protocol.version=2 \
|
|
|
|
|
clone "file://$(pwd)/file_empty_parent" file_empty_child &&
|
|
|
|
|
! grep "refs/heads/mydefaultbranch" file_empty_child/.git/HEAD
|
|
|
|
|
'
|
|
|
|
|
|
clone: handle unborn branch in bare repos
When cloning a repository with an unborn HEAD, we'll set the local HEAD
to match it only if the local repository is non-bare. This is
inconsistent with all other combinations:
remote HEAD | local repo | local HEAD
-----------------------------------------------
points to commit | non-bare | same as remote
points to commit | bare | same as remote
unborn | non-bare | same as remote
unborn | bare | local default
So I don't think this is some clever or subtle behavior, but just a bug
in 4f37d45706 (clone: respect remote unborn HEAD, 2021-02-05). And it's
easy to see how we ended up there. Before that commit, the code to set
up the HEAD for an empty repo was guarded by "if (!option_bare)". That's
because the only thing it did was call install_branch_config(), and we
don't want to do so for a bare repository (unborn HEAD or not).
That commit put the handling of unborn HEADs into the same block, since
those also need to call install_branch_config(). But the unborn case has
an additional side effect of calling create_symref(), and we want that
to happen whether we are bare or not.
This patch just pulls all of the "figure out the default branch" code
out of the "!option_bare" block. Only the actual config installation is
kept there.
Note that this does mean we might allocate "ref" and not use it (if the
remote is empty but did not advertise an unborn HEAD). But that's not
really a big deal since this isn't a hot code path, and it keeps the
code simple. The alternative would be handling unborn_head_target
separately, but that gets confusing since its memory ownership is
tangled up with the "ref" variable.
There's just one new test, for the case we're fixing. The other ones in
the table are handled elsewhere (the unborn non-bare case just above,
and the actually-born cases in t5601, t5606, and t5609, as they do not
require v2's "unborn" protocol extension).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-09-20 19:04:10 +00:00
|
|
|
test_expect_success 'bare clone propagates empty default branch' '
|
|
|
|
|
test_when_finished "rm -rf file_empty_parent file_empty_child.git" &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=mydefaultbranch init file_empty_parent &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=main -c protocol.version=2 \
|
|
|
|
|
clone --bare \
|
|
|
|
|
"file://$(pwd)/file_empty_parent" file_empty_child.git &&
|
|
|
|
|
grep "refs/heads/mydefaultbranch" file_empty_child.git/HEAD
|
|
|
|
|
'
|
|
|
|
|
|
clone: propagate empty remote HEAD even with other branches
Unless "--branch" was given, clone generally tries to match the local
HEAD to the remote one. For most repositories, this is easy: the remote
tells us which branch HEAD was pointing to, and we call our local
checkout() function on that branch.
When cloning an empty repository, it's a little more tricky: we have
special code that checks the transport's "unborn" extension, or falls back
to our local idea of what the default branch should be. In either case,
we point the new HEAD to that, and set up the branch.* config.
But that leaves one case unhandled: when the remote repository _isn't_
empty, but its HEAD is unborn. The checkout() function is smart enough
to realize we didn't fetch the remote HEAD and it bails with a warning.
But we'll have ignored any information the remote gave us via the unborn
extension. This leads to nonsense outcomes:
- If the remote has its HEAD pointing to an unborn "foo" and contains
another branch "bar", cloning will get branch "bar" but leave the
local HEAD pointing at "master" (or whatever our local default is),
which is useless. The project does not use "master" as a branch.
- Worse, if the other branch "bar" is instead called "master" (but
again, the remote HEAD is not pointing to it), then we end up with a
local unborn branch "master", which is not connected to the remote
"master" (it shares no history, and there's no branch.* config).
Instead, we should try to use the remote's HEAD, even if its unborn, to
be consistent with the other cases.
The reason this case was missed is that cmd_clone() handles empty and
non-empty repositories on two different sides of a conditional:
if (we have any refs) {
fetch refs;
check for --branch;
otherwise, try to point our head at remote head;
otherwise, our head is NULL;
} else {
check for --branch;
otherwise, try to use "unborn" extension;
otherwise, fall back to our default name name;
}
So the smallest change would be to repeat the "unborn" logic at the end
of the first block. But we can note some other overlaps and
inconsistencies:
- both sides have to handle --branch (though note that it's always an
error for the empty repo case, since an empty repo by definition
does not have a matching branch)
- the fall back to the default name is much more explicit in the
empty-repo case. The non-empty case eventually ends up bailing
from checkout() with a warning, which produces a similar result, but
fails to set up the branch config we do in the empty case.
So let's pull the HEAD setup out of this conditional entirely. This
de-duplicates some of the code and the result is easy to follow, because
helper functions like find_ref_by_name() do the right thing even in the
empty-repo case (i.e., by returning NULL).
There are two subtleties:
- for a remote with a detached HEAD, it will advertise an oid for HEAD
(which we store in our "remote_head" variable), but we won't find a
matching refname (so our "remote_head_points_at" is NULL). In this
case we make a local detached HEAD to match. Right now this happens
implicitly by reaching update_head() with a non-NULL remote_head
(since we skip all of the unborn-fallback). We'll now need to
account for it explicitly before doing the fallback.
- for an empty repo, we issue a warning to the user that they've
cloned an empty repo. The text of that warning doesn't make sense
for a non-empty repo with an unborn HEAD, so we'll have to
differentiate the two cases there. We could just use different text,
but instead let's allow the code to continue down to checkout(),
which will issue an appropriate warning, like:
remote HEAD refers to nonexistent ref, unable to checkout
Continuing down to checkout() will make it easier to do more fixes
on top (see below).
Note that this patch fixes the case where the other side reports an
unborn head to us using the protocol extension. It _doesn't_ fix the
case where the other side doesn't tell us, we locally guess "master",
and the other side happens to have a "master" which its HEAD doesn't
point. But it doesn't make anything worse there, and it should actually
make it easier to fix that problem on top.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-07-07 23:57:45 +00:00
|
|
|
test_expect_success 'clone propagates unborn HEAD from non-empty repo' '
|
|
|
|
|
test_when_finished "rm -rf file_unborn_parent file_unborn_child" &&
|
|
|
|
|
|
|
|
|
|
git init file_unborn_parent &&
|
|
|
|
|
(
|
|
|
|
|
cd file_unborn_parent &&
|
|
|
|
|
git checkout -b branchwithstuff &&
|
|
|
|
|
test_commit --no-tag stuff &&
|
|
|
|
|
git symbolic-ref HEAD refs/heads/mydefaultbranch
|
|
|
|
|
) &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=main -c protocol.version=2 \
|
|
|
|
|
clone "file://$(pwd)/file_unborn_parent" \
|
|
|
|
|
file_unborn_child 2>stderr &&
|
|
|
|
|
grep "refs/heads/mydefaultbranch" file_unborn_child/.git/HEAD &&
|
|
|
|
|
grep "warning: remote HEAD refers to nonexistent ref" stderr
|
|
|
|
|
'
|
|
|
|
|
|
2023-04-05 21:15:33 +00:00
|
|
|
test_expect_success 'clone propagates object-format from empty repo' '
|
|
|
|
|
test_when_finished "rm -fr src256 dst256" &&
|
|
|
|
|
|
|
|
|
|
echo sha256 >expect &&
|
|
|
|
|
git init --object-format=sha256 src256 &&
|
|
|
|
|
git clone src256 dst256 &&
|
|
|
|
|
git -C dst256 rev-parse --show-object-format >actual &&
|
|
|
|
|
|
|
|
|
|
test_cmp expect actual
|
|
|
|
|
'
|
|
|
|
|
|
clone: propagate empty remote HEAD even with other branches
Unless "--branch" was given, clone generally tries to match the local
HEAD to the remote one. For most repositories, this is easy: the remote
tells us which branch HEAD was pointing to, and we call our local
checkout() function on that branch.
When cloning an empty repository, it's a little more tricky: we have
special code that checks the transport's "unborn" extension, or falls back
to our local idea of what the default branch should be. In either case,
we point the new HEAD to that, and set up the branch.* config.
But that leaves one case unhandled: when the remote repository _isn't_
empty, but its HEAD is unborn. The checkout() function is smart enough
to realize we didn't fetch the remote HEAD and it bails with a warning.
But we'll have ignored any information the remote gave us via the unborn
extension. This leads to nonsense outcomes:
- If the remote has its HEAD pointing to an unborn "foo" and contains
another branch "bar", cloning will get branch "bar" but leave the
local HEAD pointing at "master" (or whatever our local default is),
which is useless. The project does not use "master" as a branch.
- Worse, if the other branch "bar" is instead called "master" (but
again, the remote HEAD is not pointing to it), then we end up with a
local unborn branch "master", which is not connected to the remote
"master" (it shares no history, and there's no branch.* config).
Instead, we should try to use the remote's HEAD, even if its unborn, to
be consistent with the other cases.
The reason this case was missed is that cmd_clone() handles empty and
non-empty repositories on two different sides of a conditional:
if (we have any refs) {
fetch refs;
check for --branch;
otherwise, try to point our head at remote head;
otherwise, our head is NULL;
} else {
check for --branch;
otherwise, try to use "unborn" extension;
otherwise, fall back to our default name name;
}
So the smallest change would be to repeat the "unborn" logic at the end
of the first block. But we can note some other overlaps and
inconsistencies:
- both sides have to handle --branch (though note that it's always an
error for the empty repo case, since an empty repo by definition
does not have a matching branch)
- the fall back to the default name is much more explicit in the
empty-repo case. The non-empty case eventually ends up bailing
from checkout() with a warning, which produces a similar result, but
fails to set up the branch config we do in the empty case.
So let's pull the HEAD setup out of this conditional entirely. This
de-duplicates some of the code and the result is easy to follow, because
helper functions like find_ref_by_name() do the right thing even in the
empty-repo case (i.e., by returning NULL).
There are two subtleties:
- for a remote with a detached HEAD, it will advertise an oid for HEAD
(which we store in our "remote_head" variable), but we won't find a
matching refname (so our "remote_head_points_at" is NULL). In this
case we make a local detached HEAD to match. Right now this happens
implicitly by reaching update_head() with a non-NULL remote_head
(since we skip all of the unborn-fallback). We'll now need to
account for it explicitly before doing the fallback.
- for an empty repo, we issue a warning to the user that they've
cloned an empty repo. The text of that warning doesn't make sense
for a non-empty repo with an unborn HEAD, so we'll have to
differentiate the two cases there. We could just use different text,
but instead let's allow the code to continue down to checkout(),
which will issue an appropriate warning, like:
remote HEAD refers to nonexistent ref, unable to checkout
Continuing down to checkout() will make it easier to do more fixes
on top (see below).
Note that this patch fixes the case where the other side reports an
unborn head to us using the protocol extension. It _doesn't_ fix the
case where the other side doesn't tell us, we locally guess "master",
and the other side happens to have a "master" which its HEAD doesn't
point. But it doesn't make anything worse there, and it should actually
make it easier to fix that problem on top.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-07-07 23:57:45 +00:00
|
|
|
test_expect_success 'bare clone propagates unborn HEAD from non-empty repo' '
|
|
|
|
|
test_when_finished "rm -rf file_unborn_parent file_unborn_child.git" &&
|
|
|
|
|
|
|
|
|
|
git init file_unborn_parent &&
|
|
|
|
|
(
|
|
|
|
|
cd file_unborn_parent &&
|
|
|
|
|
git checkout -b branchwithstuff &&
|
|
|
|
|
test_commit --no-tag stuff &&
|
|
|
|
|
git symbolic-ref HEAD refs/heads/mydefaultbranch
|
|
|
|
|
) &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=main -c protocol.version=2 \
|
|
|
|
|
clone --bare "file://$(pwd)/file_unborn_parent" \
|
|
|
|
|
file_unborn_child.git 2>stderr &&
|
|
|
|
|
grep "refs/heads/mydefaultbranch" file_unborn_child.git/HEAD &&
|
|
|
|
|
! grep "warning:" stderr
|
|
|
|
|
'
|
|
|
|
|
|
clone: use remote branch if it matches default HEAD
Usually clone tries to use the same local HEAD as the remote (unless the
user has given --branch explicitly). Even if the remote HEAD is detached
or unborn, we can detect those situations with modern versions of Git.
If the remote is too old to support the "unborn" extension (or it has
been disabled via config), then we can't know the name of the remote's
unborn HEAD, and we fall back whatever the local default branch name is
configured to be.
But that leads to one weird corner case. It's rare because it needs a
number of factors:
- the remote has an unborn HEAD
- the remote is too old to support "unborn", or has disabled it
- the remote has another branch "foo"
- the local default branch name is "foo"
In that case you end up with a local clone on an unborn "foo" branch,
disconnected completely from the remote's "foo". This is rare in
practice, but the result is quite confusing.
When choosing "foo", we can double check whether the remote has such a
name, and if so, start our local "foo" at the same spot, rather than
making it unborn.
Note that this causes a test failure in t5605, which is cloning from a
bundle that doesn't contain HEAD (so it behaves like a remote that
doesn't support "unborn"), but has a single "main" branch. That test
expects that we end up in the weird "unborn main" case, where we don't
actually check out the remote branch of the same name. Even though we
have to update the test, this seems like an argument in favor of this
patch: checking out main is what I'd expect from such a bundle.
So this patch updates the test for the new behavior and adds an adjacent
one that checks what the original was going for: if there's no HEAD and
the bundle _doesn't_ have a branch that matches our local default name,
then we end up with nothing checked out.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-07-07 23:59:35 +00:00
|
|
|
test_expect_success 'defaulted HEAD uses remote branch if available' '
|
|
|
|
|
test_when_finished "rm -rf file_unborn_parent file_unborn_child" &&
|
|
|
|
|
|
|
|
|
|
git init file_unborn_parent &&
|
|
|
|
|
(
|
|
|
|
|
cd file_unborn_parent &&
|
|
|
|
|
git config lsrefs.unborn ignore &&
|
|
|
|
|
git checkout -b branchwithstuff &&
|
|
|
|
|
test_commit --no-tag stuff &&
|
|
|
|
|
git symbolic-ref HEAD refs/heads/mydefaultbranch
|
|
|
|
|
) &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME= \
|
|
|
|
|
git -c init.defaultBranch=branchwithstuff -c protocol.version=2 \
|
|
|
|
|
clone "file://$(pwd)/file_unborn_parent" \
|
|
|
|
|
file_unborn_child 2>stderr &&
|
|
|
|
|
grep "refs/heads/branchwithstuff" file_unborn_child/.git/HEAD &&
|
|
|
|
|
test_path_is_file file_unborn_child/stuff.t &&
|
|
|
|
|
! grep "warning:" stderr
|
|
|
|
|
'
|
|
|
|
|
|
2018-03-15 17:31:28 +00:00
|
|
|
test_expect_success 'fetch with file:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_commit -C file_parent two &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C file_child -c protocol.version=2 \
|
|
|
|
|
fetch origin &&
|
|
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C file_child log -1 --format=%s origin/main >actual &&
|
2018-03-15 17:31:28 +00:00
|
|
|
git -C file_parent log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "fetch< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
2019-11-05 17:07:25 +00:00
|
|
|
test_expect_success 'ref advertisement is filtered during fetch using protocol v2' '
|
2018-03-15 17:31:28 +00:00
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_commit -C file_parent three &&
|
2018-06-05 21:40:36 +00:00
|
|
|
git -C file_parent branch unwanted-branch three &&
|
2018-03-15 17:31:28 +00:00
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C file_child -c protocol.version=2 \
|
2020-11-18 23:44:35 +00:00
|
|
|
fetch origin main &&
|
2018-03-15 17:31:28 +00:00
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C file_child log -1 --format=%s origin/main >actual &&
|
2018-03-15 17:31:28 +00:00
|
|
|
git -C file_parent log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
grep "refs/heads/main" log &&
|
2018-06-05 21:40:36 +00:00
|
|
|
! grep "refs/heads/unwanted-branch" log
|
2018-03-15 17:31:28 +00:00
|
|
|
'
|
|
|
|
|
|
2018-04-23 22:46:24 +00:00
|
|
|
test_expect_success 'server-options are sent when fetching' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_commit -C file_parent four &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C file_child -c protocol.version=2 \
|
2020-11-18 23:44:35 +00:00
|
|
|
fetch -o hello -o world origin main &&
|
2018-04-23 22:46:24 +00:00
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C file_child log -1 --format=%s origin/main >actual &&
|
2018-04-23 22:46:24 +00:00
|
|
|
git -C file_parent log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
grep "server-option=hello" log &&
|
|
|
|
|
grep "server-option=world" log
|
|
|
|
|
'
|
|
|
|
|
|
2019-04-12 19:51:21 +00:00
|
|
|
test_expect_success 'warn if using server-option with fetch with legacy protocol' '
|
|
|
|
|
test_when_finished "rm -rf temp_child" &&
|
|
|
|
|
|
|
|
|
|
git init temp_child &&
|
|
|
|
|
|
|
|
|
|
test_must_fail env GIT_TEST_PROTOCOL_VERSION=0 git -C temp_child -c protocol.version=0 \
|
2020-11-18 23:44:35 +00:00
|
|
|
fetch -o hello -o world "file://$(pwd)/file_parent" main 2>err &&
|
2019-04-12 19:51:21 +00:00
|
|
|
|
|
|
|
|
test_i18ngrep "see protocol.version in" err &&
|
|
|
|
|
test_i18ngrep "server options require protocol version 2 or later" err
|
|
|
|
|
'
|
|
|
|
|
|
2019-04-12 19:51:22 +00:00
|
|
|
test_expect_success 'server-options are sent when cloning' '
|
|
|
|
|
test_when_finished "rm -rf log myclone" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
clone --server-option=hello --server-option=world \
|
|
|
|
|
"file://$(pwd)/file_parent" myclone &&
|
|
|
|
|
|
|
|
|
|
grep "server-option=hello" log &&
|
|
|
|
|
grep "server-option=world" log
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'warn if using server-option with clone with legacy protocol' '
|
|
|
|
|
test_when_finished "rm -rf myclone" &&
|
|
|
|
|
|
|
|
|
|
test_must_fail env GIT_TEST_PROTOCOL_VERSION=0 git -c protocol.version=0 \
|
|
|
|
|
clone --server-option=hello --server-option=world \
|
|
|
|
|
"file://$(pwd)/file_parent" myclone 2>err &&
|
|
|
|
|
|
|
|
|
|
test_i18ngrep "see protocol.version in" err &&
|
|
|
|
|
test_i18ngrep "server options require protocol version 2 or later" err
|
|
|
|
|
'
|
|
|
|
|
|
2018-05-03 23:46:55 +00:00
|
|
|
test_expect_success 'upload-pack respects config using protocol v2' '
|
|
|
|
|
git init server &&
|
|
|
|
|
write_script server/.git/hook <<-\EOF &&
|
|
|
|
|
touch hookout
|
|
|
|
|
"$@"
|
|
|
|
|
EOF
|
|
|
|
|
test_commit -C server one &&
|
|
|
|
|
|
|
|
|
|
test_config_global uploadpack.packobjectshook ./hook &&
|
|
|
|
|
test_path_is_missing server/.git/hookout &&
|
|
|
|
|
git -c protocol.version=2 clone "file://$(pwd)/server" client &&
|
|
|
|
|
test_path_is_file server/.git/hookout
|
|
|
|
|
'
|
|
|
|
|
|
2018-05-03 23:46:56 +00:00
|
|
|
test_expect_success 'setup filter tests' '
|
|
|
|
|
rm -rf server client &&
|
|
|
|
|
git init server &&
|
|
|
|
|
|
|
|
|
|
# 1 commit to create a file, and 1 commit to modify it
|
|
|
|
|
test_commit -C server message1 a.txt &&
|
|
|
|
|
test_commit -C server message2 a.txt &&
|
|
|
|
|
git -C server config protocol.version 2 &&
|
|
|
|
|
git -C server config uploadpack.allowfilter 1 &&
|
|
|
|
|
git -C server config uploadpack.allowanysha1inwant 1 &&
|
|
|
|
|
git -C server config protocol.version 2
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'partial clone' '
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -c protocol.version=2 \
|
|
|
|
|
clone --filter=blob:none "file://$(pwd)/server" client &&
|
|
|
|
|
grep "version 2" trace &&
|
|
|
|
|
|
|
|
|
|
# Ensure that the old version of the file is missing
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C client rev-list --quiet --objects --missing=print main \
|
2018-05-03 23:46:56 +00:00
|
|
|
>observed.oids &&
|
|
|
|
|
grep "$(git -C server rev-parse message1:a.txt)" observed.oids &&
|
|
|
|
|
|
|
|
|
|
# Ensure that client passes fsck
|
|
|
|
|
git -C client fsck
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'dynamically fetch missing object' '
|
|
|
|
|
rm "$(pwd)/trace" &&
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -C client -c protocol.version=2 \
|
|
|
|
|
cat-file -p $(git -C server rev-parse message1:a.txt) &&
|
|
|
|
|
grep "version 2" trace
|
|
|
|
|
'
|
|
|
|
|
|
2018-09-27 19:24:05 +00:00
|
|
|
test_expect_success 'when dynamically fetching missing object, do not list refs' '
|
|
|
|
|
! grep "git> command=ls-refs" trace
|
|
|
|
|
'
|
|
|
|
|
|
2018-05-03 23:46:56 +00:00
|
|
|
test_expect_success 'partial fetch' '
|
|
|
|
|
rm -rf client "$(pwd)/trace" &&
|
|
|
|
|
git init client &&
|
|
|
|
|
SERVER="file://$(pwd)/server" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -C client -c protocol.version=2 \
|
2020-11-18 23:44:35 +00:00
|
|
|
fetch --filter=blob:none "$SERVER" main:refs/heads/other &&
|
2018-05-03 23:46:56 +00:00
|
|
|
grep "version 2" trace &&
|
|
|
|
|
|
|
|
|
|
# Ensure that the old version of the file is missing
|
2018-10-05 21:54:07 +00:00
|
|
|
git -C client rev-list --quiet --objects --missing=print other \
|
2018-05-03 23:46:56 +00:00
|
|
|
>observed.oids &&
|
|
|
|
|
grep "$(git -C server rev-parse message1:a.txt)" observed.oids &&
|
|
|
|
|
|
|
|
|
|
# Ensure that client passes fsck
|
|
|
|
|
git -C client fsck
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'do not advertise filter if not configured to do so' '
|
|
|
|
|
SERVER="file://$(pwd)/server" &&
|
|
|
|
|
|
|
|
|
|
rm "$(pwd)/trace" &&
|
|
|
|
|
git -C server config uploadpack.allowfilter 1 &&
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -c protocol.version=2 \
|
|
|
|
|
ls-remote "$SERVER" &&
|
|
|
|
|
grep "fetch=.*filter" trace &&
|
|
|
|
|
|
|
|
|
|
rm "$(pwd)/trace" &&
|
|
|
|
|
git -C server config uploadpack.allowfilter 0 &&
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -c protocol.version=2 \
|
|
|
|
|
ls-remote "$SERVER" &&
|
|
|
|
|
grep "fetch=" trace >fetch_capabilities &&
|
|
|
|
|
! grep filter fetch_capabilities
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'partial clone warns if filter is not advertised' '
|
|
|
|
|
rm -rf client &&
|
|
|
|
|
git -C server config uploadpack.allowfilter 0 &&
|
|
|
|
|
git -c protocol.version=2 \
|
|
|
|
|
clone --filter=blob:none "file://$(pwd)/server" client 2>err &&
|
|
|
|
|
test_i18ngrep "filtering not recognized by server, ignoring" err
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'even with handcrafted request, filter does not work if not advertised' '
|
|
|
|
|
git -C server config uploadpack.allowfilter 0 &&
|
|
|
|
|
|
|
|
|
|
# Custom request that tries to filter even though it is not advertised.
|
2018-09-09 17:36:28 +00:00
|
|
|
test-tool pkt-line pack >in <<-EOF &&
|
2018-05-03 23:46:56 +00:00
|
|
|
command=fetch
|
2020-06-19 17:55:56 +00:00
|
|
|
object-format=$(test_oid algo)
|
2018-05-03 23:46:56 +00:00
|
|
|
0001
|
2020-11-18 23:44:35 +00:00
|
|
|
want $(git -C server rev-parse main)
|
2018-05-03 23:46:56 +00:00
|
|
|
filter blob:none
|
|
|
|
|
0000
|
|
|
|
|
EOF
|
|
|
|
|
|
2019-04-18 13:16:51 +00:00
|
|
|
test_must_fail test-tool -C server serve-v2 --stateless-rpc \
|
|
|
|
|
<in >/dev/null 2>err &&
|
2018-05-03 23:46:56 +00:00
|
|
|
grep "unexpected line: .filter blob:none." err &&
|
|
|
|
|
|
|
|
|
|
# Exercise to ensure that if advertised, filter works
|
|
|
|
|
git -C server config uploadpack.allowfilter 1 &&
|
2019-04-18 13:16:51 +00:00
|
|
|
test-tool -C server serve-v2 --stateless-rpc <in >/dev/null
|
2018-05-03 23:46:56 +00:00
|
|
|
'
|
|
|
|
|
|
2018-05-16 23:48:22 +00:00
|
|
|
test_expect_success 'default refspec is used to filter ref when fetchcing' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C file_child -c protocol.version=2 \
|
|
|
|
|
fetch origin &&
|
|
|
|
|
|
|
|
|
|
git -C file_child log -1 --format=%s three >actual &&
|
|
|
|
|
git -C file_parent log -1 --format=%s three >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
grep "ref-prefix refs/heads/" log &&
|
|
|
|
|
grep "ref-prefix refs/tags/" log
|
|
|
|
|
'
|
|
|
|
|
|
2018-06-05 21:40:35 +00:00
|
|
|
test_expect_success 'fetch supports various ways of have lines' '
|
|
|
|
|
rm -rf server client trace &&
|
|
|
|
|
git init server &&
|
|
|
|
|
test_commit -C server dwim &&
|
|
|
|
|
TREE=$(git -C server rev-parse HEAD^{tree}) &&
|
|
|
|
|
git -C server tag exact \
|
|
|
|
|
$(git -C server commit-tree -m a "$TREE") &&
|
|
|
|
|
git -C server tag dwim-unwanted \
|
|
|
|
|
$(git -C server commit-tree -m b "$TREE") &&
|
|
|
|
|
git -C server tag exact-unwanted \
|
|
|
|
|
$(git -C server commit-tree -m c "$TREE") &&
|
|
|
|
|
git -C server tag prefix1 \
|
|
|
|
|
$(git -C server commit-tree -m d "$TREE") &&
|
|
|
|
|
git -C server tag prefix2 \
|
|
|
|
|
$(git -C server commit-tree -m e "$TREE") &&
|
|
|
|
|
git -C server tag fetch-by-sha1 \
|
|
|
|
|
$(git -C server commit-tree -m f "$TREE") &&
|
|
|
|
|
git -C server tag completely-unrelated \
|
|
|
|
|
$(git -C server commit-tree -m g "$TREE") &&
|
|
|
|
|
|
|
|
|
|
git init client &&
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -C client -c protocol.version=2 \
|
|
|
|
|
fetch "file://$(pwd)/server" \
|
|
|
|
|
dwim \
|
|
|
|
|
refs/tags/exact \
|
|
|
|
|
refs/tags/prefix*:refs/tags/prefix* \
|
|
|
|
|
"$(git -C server rev-parse fetch-by-sha1)" &&
|
|
|
|
|
|
|
|
|
|
# Ensure that the appropriate prefixes are sent (using a sample)
|
|
|
|
|
grep "fetch> ref-prefix dwim" trace &&
|
|
|
|
|
grep "fetch> ref-prefix refs/heads/dwim" trace &&
|
|
|
|
|
grep "fetch> ref-prefix refs/tags/prefix" trace &&
|
|
|
|
|
|
|
|
|
|
# Ensure that the correct objects are returned
|
|
|
|
|
git -C client cat-file -e $(git -C server rev-parse dwim) &&
|
|
|
|
|
git -C client cat-file -e $(git -C server rev-parse exact) &&
|
|
|
|
|
git -C client cat-file -e $(git -C server rev-parse prefix1) &&
|
|
|
|
|
git -C client cat-file -e $(git -C server rev-parse prefix2) &&
|
|
|
|
|
git -C client cat-file -e $(git -C server rev-parse fetch-by-sha1) &&
|
|
|
|
|
test_must_fail git -C client cat-file -e \
|
|
|
|
|
$(git -C server rev-parse dwim-unwanted) &&
|
|
|
|
|
test_must_fail git -C client cat-file -e \
|
|
|
|
|
$(git -C server rev-parse exact-unwanted) &&
|
|
|
|
|
test_must_fail git -C client cat-file -e \
|
|
|
|
|
$(git -C server rev-parse completely-unrelated)
|
|
|
|
|
'
|
|
|
|
|
|
2018-06-05 21:40:36 +00:00
|
|
|
test_expect_success 'fetch supports include-tag and tag following' '
|
|
|
|
|
rm -rf server client trace &&
|
|
|
|
|
git init server &&
|
|
|
|
|
|
|
|
|
|
test_commit -C server to_fetch &&
|
|
|
|
|
git -C server tag -a annotated_tag -m message &&
|
|
|
|
|
|
|
|
|
|
git init client &&
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -C client -c protocol.version=2 \
|
|
|
|
|
fetch "$(pwd)/server" to_fetch:to_fetch &&
|
|
|
|
|
|
|
|
|
|
grep "fetch> ref-prefix to_fetch" trace &&
|
|
|
|
|
grep "fetch> ref-prefix refs/tags/" trace &&
|
|
|
|
|
grep "fetch> include-tag" trace &&
|
|
|
|
|
|
|
|
|
|
git -C client cat-file -e $(git -C client rev-parse annotated_tag)
|
|
|
|
|
'
|
|
|
|
|
|
upload-pack: clear flags before each v2 request
Suppose a server has the following commit graph:
A B
\ /
O
We create a client by cloning A from the server with depth 1, and add
many commits to it (so that future fetches span multiple requests due to
lengthy negotiation). If it then fetches B using protocol v2, the fetch
spanning multiple requests, the resulting packfile does not contain O
even though the client did report that A is shallow.
This is because upload_pack_v2() can be called multiple times while
processing the same session. During the 2nd and all subsequent
invocations, some object flags remain from the previous invocations. In
particular, CLIENT_SHALLOW remains, preventing process_shallow() from
adding client-reported shallows to the "shallows" array, and hence
pack-objects not knowing about these client-reported shallows.
Therefore, teach upload_pack_v2() to clear object flags at the start of
each invocation. This has some other results:
- THEY_HAVE gates addition of objects to have_obj in process_haves().
Previously in upload_pack_v2(), have_obj needed to be static because
once an object is added to have_obj, it is never readded and thus we
needed to retain the contents of have_obj between invocations. Now
that flags are cleared, this is no longer necessary. This patch does
not change the behavior of ok_to_give_up() (THEY_HAVE is still set on
each "have") and got_oid() (used only in non-v2)); THEY_HAVE is not
used in any other function.
- WANTED gates addition of objects to want_obj in parse_want() and
parse_want_ref(). It is also used in receive_needs(), but that is
only used in non-v2. For the same reasons as THEY_HAVE, want_obj no
longer needs to be static in upload_pack_v2().
- CLIENT_SHALLOW is changed as discussed above.
Clearing of the other 5 flags does not affect functionality in v2. (Note
that in non-v2, upload_pack() is only called once per process, so each
invocation starts with blank flags anyway.)
- OUR_REF is only used in non-v2.
- COMMON_KNOWN is only used as a scratch flag in ok_to_give_up().
- SHALLOW is passed to invocations in deepen() and
deepen_by_rev_list(), but upload-pack doesn't use it.
- NOT_SHALLOW is used by send_shallow() and send_unshallow(), but
invocations of those functions are always preceded by code that sets
NOT_SHALLOW on the appropriate objects.
- HIDDEN_REF is only used in non-v2.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-18 20:43:29 +00:00
|
|
|
test_expect_success 'upload-pack respects client shallows' '
|
|
|
|
|
rm -rf server client trace &&
|
|
|
|
|
|
|
|
|
|
git init server &&
|
|
|
|
|
test_commit -C server base &&
|
|
|
|
|
test_commit -C server client_has &&
|
|
|
|
|
|
|
|
|
|
git clone --depth=1 "file://$(pwd)/server" client &&
|
|
|
|
|
|
|
|
|
|
# Add extra commits to the client so that the whole fetch takes more
|
|
|
|
|
# than 1 request (due to negotiation)
|
2019-06-28 09:41:54 +00:00
|
|
|
test_commit_bulk -C client --id=c 32 &&
|
upload-pack: clear flags before each v2 request
Suppose a server has the following commit graph:
A B
\ /
O
We create a client by cloning A from the server with depth 1, and add
many commits to it (so that future fetches span multiple requests due to
lengthy negotiation). If it then fetches B using protocol v2, the fetch
spanning multiple requests, the resulting packfile does not contain O
even though the client did report that A is shallow.
This is because upload_pack_v2() can be called multiple times while
processing the same session. During the 2nd and all subsequent
invocations, some object flags remain from the previous invocations. In
particular, CLIENT_SHALLOW remains, preventing process_shallow() from
adding client-reported shallows to the "shallows" array, and hence
pack-objects not knowing about these client-reported shallows.
Therefore, teach upload_pack_v2() to clear object flags at the start of
each invocation. This has some other results:
- THEY_HAVE gates addition of objects to have_obj in process_haves().
Previously in upload_pack_v2(), have_obj needed to be static because
once an object is added to have_obj, it is never readded and thus we
needed to retain the contents of have_obj between invocations. Now
that flags are cleared, this is no longer necessary. This patch does
not change the behavior of ok_to_give_up() (THEY_HAVE is still set on
each "have") and got_oid() (used only in non-v2)); THEY_HAVE is not
used in any other function.
- WANTED gates addition of objects to want_obj in parse_want() and
parse_want_ref(). It is also used in receive_needs(), but that is
only used in non-v2. For the same reasons as THEY_HAVE, want_obj no
longer needs to be static in upload_pack_v2().
- CLIENT_SHALLOW is changed as discussed above.
Clearing of the other 5 flags does not affect functionality in v2. (Note
that in non-v2, upload_pack() is only called once per process, so each
invocation starts with blank flags anyway.)
- OUR_REF is only used in non-v2.
- COMMON_KNOWN is only used as a scratch flag in ok_to_give_up().
- SHALLOW is passed to invocations in deepen() and
deepen_by_rev_list(), but upload-pack doesn't use it.
- NOT_SHALLOW is used by send_shallow() and send_unshallow(), but
invocations of those functions are always preceded by code that sets
NOT_SHALLOW on the appropriate objects.
- HIDDEN_REF is only used in non-v2.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-18 20:43:29 +00:00
|
|
|
|
|
|
|
|
git -C server checkout -b newbranch base &&
|
|
|
|
|
test_commit -C server client_wants &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -C client -c protocol.version=2 \
|
|
|
|
|
fetch origin newbranch &&
|
|
|
|
|
# Ensure that protocol v2 is used
|
|
|
|
|
grep "fetch< version 2" trace
|
fetch-pack: do not take shallow lock unnecessarily
When fetching using protocol v2, the remote may send a "shallow-info"
section if the client is shallow. If so, Git as the client currently
takes the shallow file lock, even if the "shallow-info" section is
empty.
This is not a problem except that Git does not support taking the
shallow file lock after modifying the shallow file, because
is_repository_shallow() stores information that is never cleared. And
this take-after-modify occurs when Git does a tag-following fetch from a
shallow repository on a transport that does not support tag following
(since in this case, 2 fetches are performed).
To solve this issue, take the shallow file lock (and perform all other
shallow processing) only if the "shallow-info" section is non-empty;
otherwise, behave as if it were empty.
A full solution (probably, ensuring that any action of committing
shallow file locks also includes clearing the information stored by
is_repository_shallow()) would solve the issue without need for this
patch, but this patch is independently useful (as an optimization to
prevent writing a file in an unnecessary case), hence why I wrote it. I
have included a NEEDSWORK outlining the full solution.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-01-10 19:36:45 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'ensure that multiple fetches in same process from a shallow repo works' '
|
|
|
|
|
rm -rf server client trace &&
|
|
|
|
|
|
|
|
|
|
test_create_repo server &&
|
|
|
|
|
test_commit -C server one &&
|
|
|
|
|
test_commit -C server two &&
|
|
|
|
|
test_commit -C server three &&
|
|
|
|
|
git clone --shallow-exclude two "file://$(pwd)/server" client &&
|
|
|
|
|
|
|
|
|
|
git -C server tag -a -m "an annotated tag" twotag two &&
|
|
|
|
|
|
|
|
|
|
# Triggers tag following (thus, 2 fetches in one process)
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -C client -c protocol.version=2 \
|
|
|
|
|
fetch --shallow-exclude one origin &&
|
|
|
|
|
# Ensure that protocol v2 is used
|
|
|
|
|
grep "fetch< version 2" trace
|
upload-pack: clear flags before each v2 request
Suppose a server has the following commit graph:
A B
\ /
O
We create a client by cloning A from the server with depth 1, and add
many commits to it (so that future fetches span multiple requests due to
lengthy negotiation). If it then fetches B using protocol v2, the fetch
spanning multiple requests, the resulting packfile does not contain O
even though the client did report that A is shallow.
This is because upload_pack_v2() can be called multiple times while
processing the same session. During the 2nd and all subsequent
invocations, some object flags remain from the previous invocations. In
particular, CLIENT_SHALLOW remains, preventing process_shallow() from
adding client-reported shallows to the "shallows" array, and hence
pack-objects not knowing about these client-reported shallows.
Therefore, teach upload_pack_v2() to clear object flags at the start of
each invocation. This has some other results:
- THEY_HAVE gates addition of objects to have_obj in process_haves().
Previously in upload_pack_v2(), have_obj needed to be static because
once an object is added to have_obj, it is never readded and thus we
needed to retain the contents of have_obj between invocations. Now
that flags are cleared, this is no longer necessary. This patch does
not change the behavior of ok_to_give_up() (THEY_HAVE is still set on
each "have") and got_oid() (used only in non-v2)); THEY_HAVE is not
used in any other function.
- WANTED gates addition of objects to want_obj in parse_want() and
parse_want_ref(). It is also used in receive_needs(), but that is
only used in non-v2. For the same reasons as THEY_HAVE, want_obj no
longer needs to be static in upload_pack_v2().
- CLIENT_SHALLOW is changed as discussed above.
Clearing of the other 5 flags does not affect functionality in v2. (Note
that in non-v2, upload_pack() is only called once per process, so each
invocation starts with blank flags anyway.)
- OUR_REF is only used in non-v2.
- COMMON_KNOWN is only used as a scratch flag in ok_to_give_up().
- SHALLOW is passed to invocations in deepen() and
deepen_by_rev_list(), but upload-pack doesn't use it.
- NOT_SHALLOW is used by send_shallow() and send_unshallow(), but
invocations of those functions are always preceded by code that sets
NOT_SHALLOW on the appropriate objects.
- HIDDEN_REF is only used in non-v2.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-18 20:43:29 +00:00
|
|
|
'
|
|
|
|
|
|
2018-12-18 21:24:35 +00:00
|
|
|
test_expect_success 'deepen-relative' '
|
|
|
|
|
rm -rf server client trace &&
|
|
|
|
|
|
|
|
|
|
test_create_repo server &&
|
|
|
|
|
test_commit -C server one &&
|
|
|
|
|
test_commit -C server two &&
|
|
|
|
|
test_commit -C server three &&
|
|
|
|
|
git clone --depth 1 "file://$(pwd)/server" client &&
|
|
|
|
|
test_commit -C server four &&
|
|
|
|
|
|
|
|
|
|
# Sanity check that only "three" is downloaded
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C client log --pretty=tformat:%s main >actual &&
|
2018-12-18 21:24:35 +00:00
|
|
|
echo three >expected &&
|
|
|
|
|
test_cmp expected actual &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/trace" git -C client -c protocol.version=2 \
|
|
|
|
|
fetch --deepen=1 origin &&
|
|
|
|
|
# Ensure that protocol v2 is used
|
|
|
|
|
grep "fetch< version 2" trace &&
|
|
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C client log --pretty=tformat:%s origin/main >actual &&
|
2018-12-18 21:24:35 +00:00
|
|
|
cat >expected <<-\EOF &&
|
|
|
|
|
four
|
|
|
|
|
three
|
|
|
|
|
two
|
|
|
|
|
EOF
|
|
|
|
|
test_cmp expected actual
|
|
|
|
|
'
|
|
|
|
|
|
fetch: teach independent negotiation (no packfile)
Currently, the packfile negotiation step within a Git fetch cannot be
done independent of sending the packfile, even though there is at least
one application wherein this is useful. Therefore, make it possible for
this negotiation step to be done independently. A subsequent commit will
use this for one such application - push negotiation.
This feature is for protocol v2 only. (An implementation for protocol v0
would require a separate implementation in the fetch, transport, and
transport helper code.)
In the protocol, the main hindrance towards independent negotiation is
that the server can unilaterally decide to send the packfile. This is
solved by a "wait-for-done" argument: the server will then wait for the
client to say "done". In practice, the client will never say it; instead
it will cease requests once it is satisfied.
In the client, the main change lies in the transport and transport
helper code. fetch_refs_via_pack() performs everything needed - protocol
version and capability checks, and the negotiation itself.
There are 2 code paths that do not go through fetch_refs_via_pack() that
needed to be individually excluded: the bundle transport (excluded
through requiring smart_options, which the bundle transport doesn't
support) and transport helpers that do not support takeover. If or when
we support independent negotiation for protocol v0, we will need to
modify these 2 code paths to support it. But for now, report failure if
independent negotiation is requested in these cases.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 21:16:01 +00:00
|
|
|
setup_negotiate_only () {
|
|
|
|
|
SERVER="$1"
|
|
|
|
|
URI="$2"
|
|
|
|
|
|
|
|
|
|
rm -rf "$SERVER" client
|
|
|
|
|
|
|
|
|
|
git init "$SERVER"
|
|
|
|
|
test_commit -C "$SERVER" one
|
|
|
|
|
test_commit -C "$SERVER" two
|
|
|
|
|
|
|
|
|
|
git clone "$URI" client
|
|
|
|
|
test_commit -C client three
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-08 10:53:15 +00:00
|
|
|
test_expect_success 'usage: --negotiate-only without --negotiation-tip' '
|
|
|
|
|
SERVER="server" &&
|
|
|
|
|
URI="file://$(pwd)/server" &&
|
|
|
|
|
|
|
|
|
|
setup_negotiate_only "$SERVER" "$URI" &&
|
|
|
|
|
|
|
|
|
|
cat >err.expect <<-\EOF &&
|
2022-01-28 14:36:02 +00:00
|
|
|
fatal: --negotiate-only needs one or more --negotiation-tip=*
|
2021-07-08 10:53:15 +00:00
|
|
|
EOF
|
|
|
|
|
|
|
|
|
|
test_must_fail git -c protocol.version=2 -C client fetch \
|
|
|
|
|
--negotiate-only \
|
|
|
|
|
origin 2>err.actual &&
|
|
|
|
|
test_cmp err.expect err.actual
|
|
|
|
|
'
|
|
|
|
|
|
2022-01-19 00:00:56 +00:00
|
|
|
test_expect_success 'usage: --negotiate-only with --recurse-submodules' '
|
|
|
|
|
cat >err.expect <<-\EOF &&
|
2022-01-20 21:58:43 +00:00
|
|
|
fatal: options '\''--negotiate-only'\'' and '\''--recurse-submodules'\'' cannot be used together
|
2022-01-19 00:00:56 +00:00
|
|
|
EOF
|
|
|
|
|
|
|
|
|
|
test_must_fail git -c protocol.version=2 -C client fetch \
|
|
|
|
|
--negotiate-only \
|
|
|
|
|
--recurse-submodules \
|
|
|
|
|
origin 2>err.actual &&
|
|
|
|
|
test_cmp err.expect err.actual
|
|
|
|
|
'
|
|
|
|
|
|
fetch: teach independent negotiation (no packfile)
Currently, the packfile negotiation step within a Git fetch cannot be
done independent of sending the packfile, even though there is at least
one application wherein this is useful. Therefore, make it possible for
this negotiation step to be done independently. A subsequent commit will
use this for one such application - push negotiation.
This feature is for protocol v2 only. (An implementation for protocol v0
would require a separate implementation in the fetch, transport, and
transport helper code.)
In the protocol, the main hindrance towards independent negotiation is
that the server can unilaterally decide to send the packfile. This is
solved by a "wait-for-done" argument: the server will then wait for the
client to say "done". In practice, the client will never say it; instead
it will cease requests once it is satisfied.
In the client, the main change lies in the transport and transport
helper code. fetch_refs_via_pack() performs everything needed - protocol
version and capability checks, and the negotiation itself.
There are 2 code paths that do not go through fetch_refs_via_pack() that
needed to be individually excluded: the bundle transport (excluded
through requiring smart_options, which the bundle transport doesn't
support) and transport helpers that do not support takeover. If or when
we support independent negotiation for protocol v0, we will need to
modify these 2 code paths to support it. But for now, report failure if
independent negotiation is requested in these cases.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 21:16:01 +00:00
|
|
|
test_expect_success 'file:// --negotiate-only' '
|
|
|
|
|
SERVER="server" &&
|
|
|
|
|
URI="file://$(pwd)/server" &&
|
|
|
|
|
|
|
|
|
|
setup_negotiate_only "$SERVER" "$URI" &&
|
|
|
|
|
|
|
|
|
|
git -c protocol.version=2 -C client fetch \
|
|
|
|
|
--no-tags \
|
|
|
|
|
--negotiate-only \
|
|
|
|
|
--negotiation-tip=$(git -C client rev-parse HEAD) \
|
|
|
|
|
origin >out &&
|
|
|
|
|
COMMON=$(git -C "$SERVER" rev-parse two) &&
|
|
|
|
|
grep "$COMMON" out
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'file:// --negotiate-only with protocol v0' '
|
|
|
|
|
SERVER="server" &&
|
|
|
|
|
URI="file://$(pwd)/server" &&
|
|
|
|
|
|
|
|
|
|
setup_negotiate_only "$SERVER" "$URI" &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git -c protocol.version=0 -C client fetch \
|
|
|
|
|
--no-tags \
|
|
|
|
|
--negotiate-only \
|
|
|
|
|
--negotiation-tip=$(git -C client rev-parse HEAD) \
|
|
|
|
|
origin 2>err &&
|
|
|
|
|
test_i18ngrep "negotiate-only requires protocol v2" err
|
|
|
|
|
'
|
|
|
|
|
|
git_connect(): fix corner cases in downgrading v2 to v0
There's code in git_connect() that checks whether we are doing a push
with protocol_v2, and if so, drops us to protocol_v0 (since we know
how to do v2 only for fetches). But it misses some corner cases:
1. it checks the "prog" variable, which is actually the path to
receive-pack on the remote side. By default this is just
"git-receive-pack", but it could be an arbitrary string (like
"/path/to/git receive-pack", etc). We'd accidentally stay in v2
mode in this case.
2. besides "receive-pack" and "upload-pack", there's one other value
we'd expect: "upload-archive" for handling "git archive --remote".
Like receive-pack, this doesn't understand v2, and should use the
v0 protocol.
In practice, neither of these causes bugs in the real world so far. We
do send a "we understand v2" probe to the server, but since no server
implements v2 for anything but upload-pack, it's simply ignored. But
this would eventually become a problem if we do implement v2 for those
endpoints, as older clients would falsely claim to understand it,
leading to a server response they can't parse.
We can fix (1) by passing in both the program path and the "name" of the
operation. I treat the name as a string here, because that's the pattern
set in transport_connect(), which is one of our callers (we were simply
throwing away the "name" value there before).
We can fix (2) by allowing only known-v2 protocols ("upload-pack"),
rather than blocking unknown ones ("receive-pack" and "upload-archive").
That will mean whoever eventually implements v2 push will have to adjust
this list, but that's reasonable. We'll do the safe, conservative thing
(sticking to v0) by default, and anybody working on v2 will quickly
realize this spot needs to be updated.
The new tests cover the receive-pack and upload-archive cases above, and
re-confirm that we allow v2 with an arbitrary "--upload-pack" path (that
already worked before this patch, of course, but it would be an easy
thing to break if we flipped the allow/block logic without also handling
"name" separately).
Here are a few miscellaneous implementation notes, since I had to do a
little head-scratching to understand who calls what:
- transport_connect() is called only for git-upload-archive. For
non-http git remotes, that resolves to the virtual connect_git()
function (which then calls git_connect(); confused yet?). So
plumbing through "name" in connect_git() covers that.
- for regular fetches and pushes, callers use higher-level functions
like transport_fetch_refs(). For non-http git remotes, that means
calling git_connect() under the hood via connect_setup(). And that
uses the "for_push" flag to decide which name to use.
- likewise, plumbing like fetch-pack and send-pack may call
git_connect() directly; they each know which name to use.
- for remote helpers (including http), we already have separate
parameters for "name" and "exec" (another name for "prog"). In
process_connect_service(), we feed the "name" to the helper via
"connect" or "stateless-connect" directives.
There's also a "servpath" option, which can be used to tell the
helper about the "exec" path. But no helpers we implement support
it! For http it would be useless anyway (no reasonable server
implementation will allow you to send a shell command to run the
server). In theory it would be useful for more obscure helpers like
remote-ext, but even there it is not implemented.
It's tempting to get rid of it simply to reduce confusion, but we
have publicly documented it since it was added in fa8c097cc9
(Support remote helpers implementing smart transports, 2009-12-09),
so it's possible some helper in the wild is using it.
- So for v2, helpers (again, including http) are mainly used via
stateless-connect, driven by the main program. But they do still
need to decide whether to do a v2 probe. And so there's similar
logic in remote-curl.c's discover_refs() that looks for
"git-receive-pack". But it's not buggy in the same way. Since it
doesn't support servpath, it is always dealing with a "service"
string like "git-receive-pack". And since it doesn't support
straight "connect", it can't be used for "upload-archive".
So we could leave that spot alone. But I've updated it here to match
the logic we're changing in connect_git(). That seems like the least
confusing thing for somebody who has to touch both of these spots
later (say, to add v2 push support). I didn't add a new test to make
sure this doesn't break anything; we already have several tests (in
t5551 and elsewhere) that make sure we are using v2 over http.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-03-17 19:08:51 +00:00
|
|
|
test_expect_success 'push with custom path does not request v2' '
|
|
|
|
|
rm -f env.trace &&
|
|
|
|
|
git -C client push \
|
|
|
|
|
--receive-pack="env >../env.trace; git-receive-pack" \
|
|
|
|
|
origin HEAD:refs/heads/custom-push-test &&
|
|
|
|
|
test_path_is_file env.trace &&
|
|
|
|
|
! grep ^GIT_PROTOCOL env.trace
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'fetch with custom path does request v2' '
|
|
|
|
|
rm -f env.trace &&
|
|
|
|
|
git -C client fetch \
|
|
|
|
|
--upload-pack="env >../env.trace; git-upload-pack" \
|
|
|
|
|
origin HEAD &&
|
|
|
|
|
grep ^GIT_PROTOCOL=version=2 env.trace
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'archive with custom path does not request v2' '
|
|
|
|
|
rm -f env.trace &&
|
|
|
|
|
git -C client archive \
|
|
|
|
|
--exec="env >../env.trace; git-upload-archive" \
|
|
|
|
|
--remote=origin \
|
|
|
|
|
HEAD >/dev/null &&
|
|
|
|
|
test_path_is_file env.trace &&
|
|
|
|
|
! grep ^GIT_PROTOCOL env.trace
|
|
|
|
|
'
|
|
|
|
|
|
2018-03-15 17:31:41 +00:00
|
|
|
# Test protocol v2 with 'http://' transport
|
|
|
|
|
#
|
|
|
|
|
. "$TEST_DIRECTORY"/lib-httpd.sh
|
|
|
|
|
start_httpd
|
|
|
|
|
|
|
|
|
|
test_expect_success 'create repo to be served by http:// transport' '
|
|
|
|
|
git init "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
git -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" config http.receivepack true &&
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" one
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'clone with http:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" GIT_TRACE_CURL="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
git -C http_child log -1 --format=%s >actual &&
|
|
|
|
|
git -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "Git-Protocol: version=2" log &&
|
|
|
|
|
# Server responded using protocol v2
|
2019-02-21 20:24:41 +00:00
|
|
|
grep "git< version 2" log &&
|
|
|
|
|
# Verify that the chunked encoding sending codepath is NOT exercised
|
|
|
|
|
! grep "Send header: Transfer-Encoding: chunked" log
|
|
|
|
|
'
|
|
|
|
|
|
2020-05-19 10:53:58 +00:00
|
|
|
test_expect_success 'clone repository with http:// using protocol v2 with incomplete pktline length' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
git init "$HTTPD_DOCUMENT_ROOT_PATH/incomplete_length" &&
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/incomplete_length" file &&
|
|
|
|
|
|
|
|
|
|
test_must_fail env GIT_TRACE_PACKET="$(pwd)/log" GIT_TRACE_CURL="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
clone "$HTTPD_URL/smart/incomplete_length" incomplete_length_child 2>err &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "Git-Protocol: version=2" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "git< version 2" log &&
|
|
|
|
|
# Client reported appropriate failure
|
|
|
|
|
test_i18ngrep "bytes of length header were received" err
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'clone repository with http:// using protocol v2 with incomplete pktline body' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
git init "$HTTPD_DOCUMENT_ROOT_PATH/incomplete_body" &&
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/incomplete_body" file &&
|
|
|
|
|
|
|
|
|
|
test_must_fail env GIT_TRACE_PACKET="$(pwd)/log" GIT_TRACE_CURL="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
clone "$HTTPD_URL/smart/incomplete_body" incomplete_body_child 2>err &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "Git-Protocol: version=2" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "git< version 2" log &&
|
|
|
|
|
# Client reported appropriate failure
|
|
|
|
|
test_i18ngrep "bytes of body are still expected" err
|
|
|
|
|
'
|
|
|
|
|
|
2020-05-19 10:54:00 +00:00
|
|
|
test_expect_success 'clone with http:// using protocol v2 and invalid parameters' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_must_fail env GIT_TRACE_PACKET="$(pwd)/log" GIT_TRACE_CURL="$(pwd)/log" \
|
|
|
|
|
git -c protocol.version=2 \
|
|
|
|
|
clone --shallow-since=20151012 "$HTTPD_URL/smart/http_parent" http_child_invalid &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "Git-Protocol: version=2" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "git< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
2019-02-21 20:24:41 +00:00
|
|
|
test_expect_success 'clone big repository with http:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
git init "$HTTPD_DOCUMENT_ROOT_PATH/big" &&
|
|
|
|
|
# Ensure that the list of wants is greater than http.postbuffer below
|
|
|
|
|
for i in $(test_seq 1 1500)
|
|
|
|
|
do
|
|
|
|
|
# do not use here-doc, because it requires a process
|
|
|
|
|
# per loop iteration
|
|
|
|
|
echo "commit refs/heads/too-many-refs-$i" &&
|
|
|
|
|
echo "committer git <git@example.com> $i +0000" &&
|
|
|
|
|
echo "data 0" &&
|
|
|
|
|
echo "M 644 inline bla.txt" &&
|
|
|
|
|
echo "data 4" &&
|
2021-12-09 05:11:14 +00:00
|
|
|
echo "bla" || return 1
|
2019-02-21 20:24:41 +00:00
|
|
|
done | git -C "$HTTPD_DOCUMENT_ROOT_PATH/big" fast-import &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" GIT_TRACE_CURL="$(pwd)/log" git \
|
|
|
|
|
-c protocol.version=2 -c http.postbuffer=65536 \
|
|
|
|
|
clone "$HTTPD_URL/smart/big" big_child &&
|
|
|
|
|
|
|
|
|
|
# Client requested to use protocol v2
|
|
|
|
|
grep "Git-Protocol: version=2" log &&
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "git< version 2" log &&
|
|
|
|
|
# Verify that the chunked encoding sending codepath is exercised
|
|
|
|
|
grep "Send header: Transfer-Encoding: chunked" log
|
2018-03-15 17:31:41 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'fetch with http:// using protocol v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" two &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C http_child -c protocol.version=2 \
|
|
|
|
|
fetch &&
|
|
|
|
|
|
2020-11-18 23:44:35 +00:00
|
|
|
git -C http_child log -1 --format=%s origin/main >actual &&
|
2018-03-15 17:31:41 +00:00
|
|
|
git -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" log -1 --format=%s >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "git< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
transport-helper: skip ls-refs if unnecessary
Commit e70a3030e7 ("fetch: do not list refs if fetching only hashes",
2018-10-07) and its ancestors taught Git, as an optimization, to skip
the ls-refs step when it is not necessary during a protocol v2 fetch
(for example, when lazy fetching a missing object in a partial clone, or
when running "git fetch --no-tags <remote> <SHA-1>"). But that was only
done for natively supported protocols; in particular, HTTP was not
supported.
Teach Git to skip ls-refs when using remote helpers that support connect
or stateless-connect. To do this, fetch() is made an acceptable entry
point. Because fetch() can now be the first function in the vtable
called, "get_helper(transport);" has to be added to the beginning of
that function to set the transport up (if not yet set up) before
process_connect() is invoked.
When fetch() is called, the transport could be taken over (this happens
if "connect" or "stateless-connect" is successfully run without any
"fallback" response), or not. If the transport is taken over, execution
continues like execution for natively supported protocols
(fetch_refs_via_pack() is executed, which will fetch refs using ls-refs
if needed). If not, the remote helper interface will invoke
get_refs_list() if it hasn't been invoked yet, preserving existing
behavior.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-08-21 22:20:09 +00:00
|
|
|
test_expect_success 'fetch with http:// by hash without tag following with protocol v2 does not list refs' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" two_a &&
|
|
|
|
|
git -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" rev-parse two_a >two_a_hash &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C http_child -c protocol.version=2 \
|
|
|
|
|
fetch --no-tags origin $(cat two_a_hash) &&
|
|
|
|
|
|
|
|
|
|
grep "fetch< version 2" log &&
|
|
|
|
|
! grep "fetch> command=ls-refs" log
|
|
|
|
|
'
|
|
|
|
|
|
2019-01-17 23:33:05 +00:00
|
|
|
test_expect_success 'fetch from namespaced repo respects namespaces' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
git init "$HTTPD_DOCUMENT_ROOT_PATH/nsrepo" &&
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/nsrepo" one &&
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/nsrepo" two &&
|
|
|
|
|
git -C "$HTTPD_DOCUMENT_ROOT_PATH/nsrepo" \
|
2020-11-18 23:44:35 +00:00
|
|
|
update-ref refs/namespaces/ns/refs/heads/main one &&
|
2019-01-17 23:33:05 +00:00
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C http_child -c protocol.version=2 \
|
|
|
|
|
fetch "$HTTPD_URL/smart_namespace/nsrepo" \
|
2020-11-18 23:44:35 +00:00
|
|
|
refs/heads/main:refs/heads/theirs &&
|
2019-01-17 23:33:05 +00:00
|
|
|
|
|
|
|
|
# Server responded using protocol v2
|
|
|
|
|
grep "fetch< version 2" log &&
|
|
|
|
|
|
|
|
|
|
git -C "$HTTPD_DOCUMENT_ROOT_PATH/nsrepo" rev-parse one >expect &&
|
|
|
|
|
git -C http_child rev-parse theirs >actual &&
|
|
|
|
|
test_cmp expect actual
|
|
|
|
|
'
|
|
|
|
|
|
transport: don't flush when disconnecting stateless-rpc helper
Since ba227857d2 (Reduce the number of connects when fetching,
2008-02-04), when we disconnect a git transport, we send a final flush
packet. This cleanly tells the other side that we're done, and avoids
the other side complaining "the remote end hung up unexpectedly" (though
we'd only see that for transports that pass along the server stderr,
like ssh or local-host).
But when we've initiated a v2 stateless-connect session over a transport
helper, there's no point in sending this flush packet. Each operation
we've performed is self-contained, and the other side is fine with us
hanging up between operations.
But much worse, by sending the flush packet we may cause the helper to
issue an entirely new request _just_ to send the flush packet. So we can
incur an extra network request just to say "by the way, we have nothing
more to send".
Let's drop this extra flush packet. As the test shows, this reduces the
number of POSTs required for a v2 ls-remote over http from 2 to 1.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-08 07:10:09 +00:00
|
|
|
test_expect_success 'ls-remote with v2 http sends only one POST' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
|
|
|
|
|
git ls-remote "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" >expect &&
|
|
|
|
|
GIT_TRACE_CURL="$(pwd)/log" git -c protocol.version=2 \
|
|
|
|
|
ls-remote "$HTTPD_URL/smart/http_parent" >actual &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
|
|
grep "Send header: POST" log >posts &&
|
|
|
|
|
test_line_count = 1 posts
|
|
|
|
|
'
|
|
|
|
|
|
2018-03-15 17:31:42 +00:00
|
|
|
test_expect_success 'push with http:// and a config of v2 does not request v2' '
|
|
|
|
|
test_when_finished "rm -f log" &&
|
|
|
|
|
# Till v2 for push is designed, make sure that if a client has
|
|
|
|
|
# protocol.version configured to use v2, that the client instead falls
|
|
|
|
|
# back and uses v0.
|
|
|
|
|
|
|
|
|
|
test_commit -C http_child three &&
|
|
|
|
|
|
|
|
|
|
# Push to another branch, as the target repository has the
|
2020-11-18 23:44:35 +00:00
|
|
|
# main branch checked out and we cannot push into it.
|
2018-03-15 17:31:42 +00:00
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" git -C http_child -c protocol.version=2 \
|
|
|
|
|
push origin HEAD:client_branch &&
|
|
|
|
|
|
|
|
|
|
git -C http_child log -1 --format=%s >actual &&
|
|
|
|
|
git -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" log -1 --format=%s client_branch >expect &&
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
2019-11-05 17:07:24 +00:00
|
|
|
# Client did not request to use protocol v2
|
2018-03-15 17:31:42 +00:00
|
|
|
! grep "Git-Protocol: version=2" log &&
|
2019-11-05 17:07:24 +00:00
|
|
|
# Server did not respond using protocol v2
|
2018-03-15 17:31:42 +00:00
|
|
|
! grep "git< version 2" log
|
|
|
|
|
'
|
|
|
|
|
|
fetch-pack: be more precise in parsing v2 response
Each section in a protocol v2 response is followed by either a DELIM
packet (indicating more sections to follow) or a FLUSH packet
(indicating none to follow). But when parsing the "acknowledgments"
section, do_fetch_pack_v2() is liberal in accepting both, but determines
whether to continue reading or not based solely on the contents of the
"acknowledgments" section, not on whether DELIM or FLUSH was read.
There is no issue with a protocol-compliant server, but can result in
confusing error messages when communicating with a server that
serves unexpected additional sections. Consider a server that sends
"new-section" after "acknowledgments":
- client writes request
- client reads the "acknowledgments" section which contains no "ready",
then DELIM
- since there was no "ready", client needs to continue negotiation, and
writes request
- client reads "new-section", and reports to the end user "expected
'acknowledgments', received 'new-section'"
For the person debugging the involved Git implementation(s), the error
message is confusing in that "new-section" was not received in response
to the latest request, but to the first one.
One solution is to always continue reading after DELIM, but in this
case, we can do better. We know from the protocol that "ready" means at
least the packfile section is coming (hence, DELIM) and that no "ready"
means that no sections are to follow (hence, FLUSH). So teach
process_acks() to enforce this.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-19 22:54:04 +00:00
|
|
|
test_expect_success 'when server sends "ready", expect DELIM' '
|
|
|
|
|
rm -rf "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
git init "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" one &&
|
|
|
|
|
|
|
|
|
|
git clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" two &&
|
|
|
|
|
|
|
|
|
|
# After "ready" in the acknowledgments section, pretend that a FLUSH
|
|
|
|
|
# (0000) was sent instead of a DELIM (0001).
|
t/lib-httpd: avoid using macOS' sed
Among other differences relative to GNU sed, macOS' sed always ends its
output with a trailing newline, even if the input did not have such a
trailing newline.
Surprisingly, this makes three httpd-based tests fail on macOS: t5616,
t5702 and t5703. ("Surprisingly" because those tests have been around
for some time, but apparently nobody runs them on macOS with a working
Apache2 setup.)
The reason is that we use `sed` in those tests to filter the response of
the web server. Apart from the fact that we use GNU constructs (such as
using a space after the `c` command instead of a backslash and a
newline), we have another problem: macOS' sed LF-only newlines while
webservers are supposed to use CR/LF ones.
Even worse, t5616 uses `sed` to replace a binary part of the response
with a new binary part (kind of hoping that the replaced binary part
does not contain a 0x0a byte which would be interpreted as a newline).
To that end, it calls on Perl to read the binary pack file and
hex-encode it, then calls on `sed` to prefix every hex digit pair with a
`\x` in order to construct the text that the `c` statement of the `sed`
invocation is supposed to insert. So we call Perl and sed to construct a
sed statement. The final nail in the coffin is that macOS' sed does not
even interpret those `\x<hex>` constructs.
Let's just replace all of that by Perl snippets. With Perl, at least, we
do not have to deal with GNU vs macOS semantics, we do not have to worry
about unwanted trailing newlines, and we do not have to spawn commands
to construct arguments for other commands to be spawned (i.e. we can
avoid a whole lot of shell scripting complexity).
The upshot is that this fixes t5616, t5702 and t5703 on macOS with
Apache2.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-27 13:23:11 +00:00
|
|
|
printf "\$ready = 1 if /ready/; \$ready && s/0001/0000/" \
|
|
|
|
|
>"$HTTPD_ROOT_PATH/one-time-perl" &&
|
fetch-pack: be more precise in parsing v2 response
Each section in a protocol v2 response is followed by either a DELIM
packet (indicating more sections to follow) or a FLUSH packet
(indicating none to follow). But when parsing the "acknowledgments"
section, do_fetch_pack_v2() is liberal in accepting both, but determines
whether to continue reading or not based solely on the contents of the
"acknowledgments" section, not on whether DELIM or FLUSH was read.
There is no issue with a protocol-compliant server, but can result in
confusing error messages when communicating with a server that
serves unexpected additional sections. Consider a server that sends
"new-section" after "acknowledgments":
- client writes request
- client reads the "acknowledgments" section which contains no "ready",
then DELIM
- since there was no "ready", client needs to continue negotiation, and
writes request
- client reads "new-section", and reports to the end user "expected
'acknowledgments', received 'new-section'"
For the person debugging the involved Git implementation(s), the error
message is confusing in that "new-section" was not received in response
to the latest request, but to the first one.
One solution is to always continue reading after DELIM, but in this
case, we can do better. We know from the protocol that "ready" means at
least the packfile section is coming (hence, DELIM) and that no "ready"
means that no sections are to follow (hence, FLUSH). So teach
process_acks() to enforce this.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-19 22:54:04 +00:00
|
|
|
|
|
|
|
|
test_must_fail git -C http_child -c protocol.version=2 \
|
t/lib-httpd: avoid using macOS' sed
Among other differences relative to GNU sed, macOS' sed always ends its
output with a trailing newline, even if the input did not have such a
trailing newline.
Surprisingly, this makes three httpd-based tests fail on macOS: t5616,
t5702 and t5703. ("Surprisingly" because those tests have been around
for some time, but apparently nobody runs them on macOS with a working
Apache2 setup.)
The reason is that we use `sed` in those tests to filter the response of
the web server. Apart from the fact that we use GNU constructs (such as
using a space after the `c` command instead of a backslash and a
newline), we have another problem: macOS' sed LF-only newlines while
webservers are supposed to use CR/LF ones.
Even worse, t5616 uses `sed` to replace a binary part of the response
with a new binary part (kind of hoping that the replaced binary part
does not contain a 0x0a byte which would be interpreted as a newline).
To that end, it calls on Perl to read the binary pack file and
hex-encode it, then calls on `sed` to prefix every hex digit pair with a
`\x` in order to construct the text that the `c` statement of the `sed`
invocation is supposed to insert. So we call Perl and sed to construct a
sed statement. The final nail in the coffin is that macOS' sed does not
even interpret those `\x<hex>` constructs.
Let's just replace all of that by Perl snippets. With Perl, at least, we
do not have to deal with GNU vs macOS semantics, we do not have to worry
about unwanted trailing newlines, and we do not have to spawn commands
to construct arguments for other commands to be spawned (i.e. we can
avoid a whole lot of shell scripting complexity).
The upshot is that this fixes t5616, t5702 and t5703 on macOS with
Apache2.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-27 13:23:11 +00:00
|
|
|
fetch "$HTTPD_URL/one_time_perl/http_parent" 2> err &&
|
fetch-pack: be more precise in parsing v2 response
Each section in a protocol v2 response is followed by either a DELIM
packet (indicating more sections to follow) or a FLUSH packet
(indicating none to follow). But when parsing the "acknowledgments"
section, do_fetch_pack_v2() is liberal in accepting both, but determines
whether to continue reading or not based solely on the contents of the
"acknowledgments" section, not on whether DELIM or FLUSH was read.
There is no issue with a protocol-compliant server, but can result in
confusing error messages when communicating with a server that
serves unexpected additional sections. Consider a server that sends
"new-section" after "acknowledgments":
- client writes request
- client reads the "acknowledgments" section which contains no "ready",
then DELIM
- since there was no "ready", client needs to continue negotiation, and
writes request
- client reads "new-section", and reports to the end user "expected
'acknowledgments', received 'new-section'"
For the person debugging the involved Git implementation(s), the error
message is confusing in that "new-section" was not received in response
to the latest request, but to the first one.
One solution is to always continue reading after DELIM, but in this
case, we can do better. We know from the protocol that "ready" means at
least the packfile section is coming (hence, DELIM) and that no "ready"
means that no sections are to follow (hence, FLUSH). So teach
process_acks() to enforce this.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-19 22:54:04 +00:00
|
|
|
test_i18ngrep "expected packfile to be sent after .ready." err
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'when server does not send "ready", expect FLUSH' '
|
|
|
|
|
rm -rf "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" one &&
|
|
|
|
|
|
|
|
|
|
git clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
test_commit -C "$HTTPD_DOCUMENT_ROOT_PATH/http_parent" two &&
|
|
|
|
|
|
|
|
|
|
# Create many commits to extend the negotiation phase across multiple
|
|
|
|
|
# requests, so that the server does not send "ready" in the first
|
|
|
|
|
# request.
|
2019-06-28 09:41:54 +00:00
|
|
|
test_commit_bulk -C http_child --id=c 32 &&
|
fetch-pack: be more precise in parsing v2 response
Each section in a protocol v2 response is followed by either a DELIM
packet (indicating more sections to follow) or a FLUSH packet
(indicating none to follow). But when parsing the "acknowledgments"
section, do_fetch_pack_v2() is liberal in accepting both, but determines
whether to continue reading or not based solely on the contents of the
"acknowledgments" section, not on whether DELIM or FLUSH was read.
There is no issue with a protocol-compliant server, but can result in
confusing error messages when communicating with a server that
serves unexpected additional sections. Consider a server that sends
"new-section" after "acknowledgments":
- client writes request
- client reads the "acknowledgments" section which contains no "ready",
then DELIM
- since there was no "ready", client needs to continue negotiation, and
writes request
- client reads "new-section", and reports to the end user "expected
'acknowledgments', received 'new-section'"
For the person debugging the involved Git implementation(s), the error
message is confusing in that "new-section" was not received in response
to the latest request, but to the first one.
One solution is to always continue reading after DELIM, but in this
case, we can do better. We know from the protocol that "ready" means at
least the packfile section is coming (hence, DELIM) and that no "ready"
means that no sections are to follow (hence, FLUSH). So teach
process_acks() to enforce this.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-19 22:54:04 +00:00
|
|
|
|
|
|
|
|
# After the acknowledgments section, pretend that a DELIM
|
|
|
|
|
# (0001) was sent instead of a FLUSH (0000).
|
t/lib-httpd: avoid using macOS' sed
Among other differences relative to GNU sed, macOS' sed always ends its
output with a trailing newline, even if the input did not have such a
trailing newline.
Surprisingly, this makes three httpd-based tests fail on macOS: t5616,
t5702 and t5703. ("Surprisingly" because those tests have been around
for some time, but apparently nobody runs them on macOS with a working
Apache2 setup.)
The reason is that we use `sed` in those tests to filter the response of
the web server. Apart from the fact that we use GNU constructs (such as
using a space after the `c` command instead of a backslash and a
newline), we have another problem: macOS' sed LF-only newlines while
webservers are supposed to use CR/LF ones.
Even worse, t5616 uses `sed` to replace a binary part of the response
with a new binary part (kind of hoping that the replaced binary part
does not contain a 0x0a byte which would be interpreted as a newline).
To that end, it calls on Perl to read the binary pack file and
hex-encode it, then calls on `sed` to prefix every hex digit pair with a
`\x` in order to construct the text that the `c` statement of the `sed`
invocation is supposed to insert. So we call Perl and sed to construct a
sed statement. The final nail in the coffin is that macOS' sed does not
even interpret those `\x<hex>` constructs.
Let's just replace all of that by Perl snippets. With Perl, at least, we
do not have to deal with GNU vs macOS semantics, we do not have to worry
about unwanted trailing newlines, and we do not have to spawn commands
to construct arguments for other commands to be spawned (i.e. we can
avoid a whole lot of shell scripting complexity).
The upshot is that this fixes t5616, t5702 and t5703 on macOS with
Apache2.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-27 13:23:11 +00:00
|
|
|
printf "\$ack = 1 if /acknowledgments/; \$ack && s/0000/0001/" \
|
|
|
|
|
>"$HTTPD_ROOT_PATH/one-time-perl" &&
|
fetch-pack: be more precise in parsing v2 response
Each section in a protocol v2 response is followed by either a DELIM
packet (indicating more sections to follow) or a FLUSH packet
(indicating none to follow). But when parsing the "acknowledgments"
section, do_fetch_pack_v2() is liberal in accepting both, but determines
whether to continue reading or not based solely on the contents of the
"acknowledgments" section, not on whether DELIM or FLUSH was read.
There is no issue with a protocol-compliant server, but can result in
confusing error messages when communicating with a server that
serves unexpected additional sections. Consider a server that sends
"new-section" after "acknowledgments":
- client writes request
- client reads the "acknowledgments" section which contains no "ready",
then DELIM
- since there was no "ready", client needs to continue negotiation, and
writes request
- client reads "new-section", and reports to the end user "expected
'acknowledgments', received 'new-section'"
For the person debugging the involved Git implementation(s), the error
message is confusing in that "new-section" was not received in response
to the latest request, but to the first one.
One solution is to always continue reading after DELIM, but in this
case, we can do better. We know from the protocol that "ready" means at
least the packfile section is coming (hence, DELIM) and that no "ready"
means that no sections are to follow (hence, FLUSH). So teach
process_acks() to enforce this.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-19 22:54:04 +00:00
|
|
|
|
|
|
|
|
test_must_fail env GIT_TRACE_PACKET="$(pwd)/log" git -C http_child \
|
|
|
|
|
-c protocol.version=2 \
|
t/lib-httpd: avoid using macOS' sed
Among other differences relative to GNU sed, macOS' sed always ends its
output with a trailing newline, even if the input did not have such a
trailing newline.
Surprisingly, this makes three httpd-based tests fail on macOS: t5616,
t5702 and t5703. ("Surprisingly" because those tests have been around
for some time, but apparently nobody runs them on macOS with a working
Apache2 setup.)
The reason is that we use `sed` in those tests to filter the response of
the web server. Apart from the fact that we use GNU constructs (such as
using a space after the `c` command instead of a backslash and a
newline), we have another problem: macOS' sed LF-only newlines while
webservers are supposed to use CR/LF ones.
Even worse, t5616 uses `sed` to replace a binary part of the response
with a new binary part (kind of hoping that the replaced binary part
does not contain a 0x0a byte which would be interpreted as a newline).
To that end, it calls on Perl to read the binary pack file and
hex-encode it, then calls on `sed` to prefix every hex digit pair with a
`\x` in order to construct the text that the `c` statement of the `sed`
invocation is supposed to insert. So we call Perl and sed to construct a
sed statement. The final nail in the coffin is that macOS' sed does not
even interpret those `\x<hex>` constructs.
Let's just replace all of that by Perl snippets. With Perl, at least, we
do not have to deal with GNU vs macOS semantics, we do not have to worry
about unwanted trailing newlines, and we do not have to spawn commands
to construct arguments for other commands to be spawned (i.e. we can
avoid a whole lot of shell scripting complexity).
The upshot is that this fixes t5616, t5702 and t5703 on macOS with
Apache2.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-27 13:23:11 +00:00
|
|
|
fetch "$HTTPD_URL/one_time_perl/http_parent" 2> err &&
|
2019-01-16 19:28:15 +00:00
|
|
|
grep "fetch< .*acknowledgments" log &&
|
|
|
|
|
! grep "fetch< .*ready" log &&
|
fetch-pack: be more precise in parsing v2 response
Each section in a protocol v2 response is followed by either a DELIM
packet (indicating more sections to follow) or a FLUSH packet
(indicating none to follow). But when parsing the "acknowledgments"
section, do_fetch_pack_v2() is liberal in accepting both, but determines
whether to continue reading or not based solely on the contents of the
"acknowledgments" section, not on whether DELIM or FLUSH was read.
There is no issue with a protocol-compliant server, but can result in
confusing error messages when communicating with a server that
serves unexpected additional sections. Consider a server that sends
"new-section" after "acknowledgments":
- client writes request
- client reads the "acknowledgments" section which contains no "ready",
then DELIM
- since there was no "ready", client needs to continue negotiation, and
writes request
- client reads "new-section", and reports to the end user "expected
'acknowledgments', received 'new-section'"
For the person debugging the involved Git implementation(s), the error
message is confusing in that "new-section" was not received in response
to the latest request, but to the first one.
One solution is to always continue reading after DELIM, but in this
case, we can do better. We know from the protocol that "ready" means at
least the packfile section is coming (hence, DELIM) and that no "ready"
means that no sections are to follow (hence, FLUSH). So teach
process_acks() to enforce this.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-10-19 22:54:04 +00:00
|
|
|
test_i18ngrep "expected no other sections to be sent after no .ready." err
|
|
|
|
|
'
|
2018-03-15 17:31:42 +00:00
|
|
|
|
2020-06-10 20:57:23 +00:00
|
|
|
configure_exclusion () {
|
|
|
|
|
git -C "$1" hash-object "$2" >objh &&
|
|
|
|
|
git -C "$1" pack-objects "$HTTPD_DOCUMENT_ROOT_PATH/mypack" <objh >packh &&
|
|
|
|
|
git -C "$1" config --add \
|
|
|
|
|
"uploadpack.blobpackfileuri" \
|
|
|
|
|
"$(cat objh) $(cat packh) $HTTPD_URL/dumb/mypack-$(cat packh).pack" &&
|
|
|
|
|
cat objh
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
test_expect_success 'part of packfile response provided as URI' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo my-blob >"$P/my-blob" &&
|
|
|
|
|
git -C "$P" add my-blob &&
|
|
|
|
|
echo other-blob >"$P/other-blob" &&
|
|
|
|
|
git -C "$P" add other-blob &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
configure_exclusion "$P" my-blob >h &&
|
|
|
|
|
configure_exclusion "$P" other-blob >h2 &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE=1 GIT_TRACE_PACKET="$(pwd)/log" GIT_TEST_SIDEBAND_ALL=1 \
|
|
|
|
|
git -c protocol.version=2 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
# Ensure that my-blob and other-blob are in separate packfiles.
|
|
|
|
|
for idx in http_child/.git/objects/pack/*.idx
|
|
|
|
|
do
|
2020-07-29 23:14:19 +00:00
|
|
|
git verify-pack --object-format=$(test_oid algo) --verbose $idx >out &&
|
2020-06-10 20:57:23 +00:00
|
|
|
{
|
2022-09-21 13:02:30 +00:00
|
|
|
grep -E "^[0-9a-f]{16,} " out || :
|
2020-06-10 20:57:23 +00:00
|
|
|
} >out.objectlist &&
|
|
|
|
|
if test_line_count = 1 out.objectlist
|
|
|
|
|
then
|
|
|
|
|
if grep $(cat h) out
|
|
|
|
|
then
|
|
|
|
|
>hfound
|
|
|
|
|
fi &&
|
|
|
|
|
if grep $(cat h2) out
|
|
|
|
|
then
|
|
|
|
|
>h2found
|
|
|
|
|
fi
|
2021-12-09 05:11:14 +00:00
|
|
|
fi || return 1
|
2020-06-10 20:57:23 +00:00
|
|
|
done &&
|
|
|
|
|
test -f hfound &&
|
|
|
|
|
test -f h2found &&
|
|
|
|
|
|
2021-02-22 19:20:09 +00:00
|
|
|
# Ensure that there are exactly 3 packfiles with associated .idx
|
|
|
|
|
ls http_child/.git/objects/pack/*.pack \
|
|
|
|
|
http_child/.git/objects/pack/*.idx >filelist &&
|
2020-06-10 20:57:23 +00:00
|
|
|
test_line_count = 6 filelist
|
|
|
|
|
'
|
|
|
|
|
|
fetch-pack: do not mix --pack_header and packfile uri
When fetching (as opposed to cloning) from a repository with packfile
URIs enabled, an error like this may occur:
fatal: pack has bad object at offset 12: unknown object type 5
fatal: finish_http_pack_request gave result -1
fatal: fetch-pack: expected keep then TAB at start of http-fetch output
This bug was introduced in b664e9ffa1 ("fetch-pack: with packfile URIs,
use index-pack arg", 2021-02-22), when the index-pack args used when
processing the inline packfile of a fetch response and when processing
packfile URIs were unified.
This bug happens because fetch, by default, partially reads (and
consumes) the header of the inline packfile to determine if it should
store the downloaded objects as a packfile or loose objects, and thus
passes --pack_header=<...> to index-pack to inform it that some bytes
are missing. However, when it subsequently fetches the additional
packfiles linked by URIs, it reuses the same index-pack arguments, thus
wrongly passing --index-pack-arg=--pack_header=<...> when no bytes are
missing.
This does not happen when cloning because "git clone" always passes
do_keep, which instructs the fetch mechanism to always retain the
packfile, eliminating the need to read the header.
There are a few ways to fix this, including filtering out pack_header
arguments when downloading the additional packfiles, but I decided to
stick to always using index-pack throughout when packfile URIs are
present - thus, Git no longer needs to read the bytes, and no longer
needs --pack_header here.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-03-05 01:16:20 +00:00
|
|
|
test_expect_success 'packfile URIs with fetch instead of clone' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo my-blob >"$P/my-blob" &&
|
|
|
|
|
git -C "$P" add my-blob &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
configure_exclusion "$P" my-blob >h &&
|
|
|
|
|
|
|
|
|
|
git init http_child &&
|
|
|
|
|
|
|
|
|
|
GIT_TEST_SIDEBAND_ALL=1 \
|
|
|
|
|
git -C http_child -c protocol.version=2 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
fetch "$HTTPD_URL/smart/http_parent"
|
|
|
|
|
'
|
|
|
|
|
|
2020-06-10 20:57:23 +00:00
|
|
|
test_expect_success 'fetching with valid packfile URI but invalid hash fails' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo my-blob >"$P/my-blob" &&
|
|
|
|
|
git -C "$P" add my-blob &&
|
|
|
|
|
echo other-blob >"$P/other-blob" &&
|
|
|
|
|
git -C "$P" add other-blob &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
configure_exclusion "$P" my-blob >h &&
|
|
|
|
|
# Configure a URL for other-blob. Just reuse the hash of the object as
|
|
|
|
|
# the hash of the packfile, since the hash does not matter for this
|
|
|
|
|
# test as long as it is not the hash of the pack, and it is of the
|
|
|
|
|
# expected length.
|
|
|
|
|
git -C "$P" hash-object other-blob >objh &&
|
|
|
|
|
git -C "$P" pack-objects "$HTTPD_DOCUMENT_ROOT_PATH/mypack" <objh >packh &&
|
|
|
|
|
git -C "$P" config --add \
|
|
|
|
|
"uploadpack.blobpackfileuri" \
|
|
|
|
|
"$(cat objh) $(cat objh) $HTTPD_URL/dumb/mypack-$(cat packh).pack" &&
|
|
|
|
|
|
|
|
|
|
test_must_fail env GIT_TEST_SIDEBAND_ALL=1 \
|
|
|
|
|
git -c protocol.version=2 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child 2>err &&
|
|
|
|
|
test_i18ngrep "pack downloaded from.*does not match expected hash" err
|
|
|
|
|
'
|
|
|
|
|
|
2020-08-17 19:48:20 +00:00
|
|
|
test_expect_success 'packfile-uri with transfer.fsckobjects' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo my-blob >"$P/my-blob" &&
|
|
|
|
|
git -C "$P" add my-blob &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
configure_exclusion "$P" my-blob >h &&
|
|
|
|
|
|
|
|
|
|
sane_unset GIT_TEST_SIDEBAND_ALL &&
|
|
|
|
|
git -c protocol.version=2 -c transfer.fsckobjects=1 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
2021-02-22 19:20:09 +00:00
|
|
|
# Ensure that there are exactly 2 packfiles with associated .idx
|
|
|
|
|
ls http_child/.git/objects/pack/*.pack \
|
|
|
|
|
http_child/.git/objects/pack/*.idx >filelist &&
|
2020-08-17 19:48:20 +00:00
|
|
|
test_line_count = 4 filelist
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'packfile-uri with transfer.fsckobjects fails on bad object' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
cat >bogus-commit <<-EOF &&
|
|
|
|
|
tree $EMPTY_TREE
|
|
|
|
|
author Bugs Bunny 1234567890 +0000
|
|
|
|
|
committer Bugs Bunny <bugs@bun.ni> 1234567890 +0000
|
|
|
|
|
|
|
|
|
|
This commit object intentionally broken
|
|
|
|
|
EOF
|
2023-01-18 20:41:56 +00:00
|
|
|
BOGUS=$(git -C "$P" hash-object -t commit -w --stdin --literally <bogus-commit) &&
|
2020-08-17 19:48:20 +00:00
|
|
|
git -C "$P" branch bogus-branch "$BOGUS" &&
|
|
|
|
|
|
|
|
|
|
echo my-blob >"$P/my-blob" &&
|
|
|
|
|
git -C "$P" add my-blob &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
configure_exclusion "$P" my-blob >h &&
|
|
|
|
|
|
|
|
|
|
sane_unset GIT_TEST_SIDEBAND_ALL &&
|
|
|
|
|
test_must_fail git -c protocol.version=2 -c transfer.fsckobjects=1 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child 2>error &&
|
|
|
|
|
test_i18ngrep "invalid author/committer line - missing email" error
|
|
|
|
|
'
|
|
|
|
|
|
2021-02-22 19:20:09 +00:00
|
|
|
test_expect_success 'packfile-uri with transfer.fsckobjects succeeds when .gitmodules is separate from tree' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo "[submodule libfoo]" >"$P/.gitmodules" &&
|
|
|
|
|
echo "path = include/foo" >>"$P/.gitmodules" &&
|
|
|
|
|
echo "url = git://example.com/git/lib.git" >>"$P/.gitmodules" &&
|
|
|
|
|
git -C "$P" add .gitmodules &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
configure_exclusion "$P" .gitmodules >h &&
|
|
|
|
|
|
|
|
|
|
sane_unset GIT_TEST_SIDEBAND_ALL &&
|
|
|
|
|
git -c protocol.version=2 -c transfer.fsckobjects=1 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
# Ensure that there are exactly 2 packfiles with associated .idx
|
|
|
|
|
ls http_child/.git/objects/pack/*.pack \
|
|
|
|
|
http_child/.git/objects/pack/*.idx >filelist &&
|
|
|
|
|
test_line_count = 4 filelist
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'packfile-uri with transfer.fsckobjects fails when .gitmodules separate from tree is invalid' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child err &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo "[submodule \"..\"]" >"$P/.gitmodules" &&
|
|
|
|
|
echo "path = include/foo" >>"$P/.gitmodules" &&
|
|
|
|
|
echo "url = git://example.com/git/lib.git" >>"$P/.gitmodules" &&
|
|
|
|
|
git -C "$P" add .gitmodules &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
configure_exclusion "$P" .gitmodules >h &&
|
|
|
|
|
|
|
|
|
|
sane_unset GIT_TEST_SIDEBAND_ALL &&
|
|
|
|
|
test_must_fail git -c protocol.version=2 -c transfer.fsckobjects=1 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child 2>err &&
|
|
|
|
|
test_i18ngrep "disallowed submodule name" err
|
|
|
|
|
'
|
|
|
|
|
|
2021-11-10 23:51:28 +00:00
|
|
|
test_expect_success 'packfile-uri path redacted in trace' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo my-blob >"$P/my-blob" &&
|
|
|
|
|
git -C "$P" add my-blob &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
git -C "$P" hash-object my-blob >objh &&
|
|
|
|
|
git -C "$P" pack-objects "$HTTPD_DOCUMENT_ROOT_PATH/mypack" <objh >packh &&
|
|
|
|
|
git -C "$P" config --add \
|
|
|
|
|
"uploadpack.blobpackfileuri" \
|
|
|
|
|
"$(cat objh) $(cat packh) $HTTPD_URL/dumb/mypack-$(cat packh).pack" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" \
|
|
|
|
|
git -c protocol.version=2 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
grep -F "clone< \\1$(cat packh) $HTTPD_URL/<redacted>" log
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'packfile-uri path not redacted in trace when GIT_TRACE_REDACT=0' '
|
|
|
|
|
P="$HTTPD_DOCUMENT_ROOT_PATH/http_parent" &&
|
|
|
|
|
rm -rf "$P" http_child log &&
|
|
|
|
|
|
|
|
|
|
git init "$P" &&
|
|
|
|
|
git -C "$P" config "uploadpack.allowsidebandall" "true" &&
|
|
|
|
|
|
|
|
|
|
echo my-blob >"$P/my-blob" &&
|
|
|
|
|
git -C "$P" add my-blob &&
|
|
|
|
|
git -C "$P" commit -m x &&
|
|
|
|
|
|
|
|
|
|
git -C "$P" hash-object my-blob >objh &&
|
|
|
|
|
git -C "$P" pack-objects "$HTTPD_DOCUMENT_ROOT_PATH/mypack" <objh >packh &&
|
|
|
|
|
git -C "$P" config --add \
|
|
|
|
|
"uploadpack.blobpackfileuri" \
|
|
|
|
|
"$(cat objh) $(cat packh) $HTTPD_URL/dumb/mypack-$(cat packh).pack" &&
|
|
|
|
|
|
|
|
|
|
GIT_TRACE_PACKET="$(pwd)/log" \
|
|
|
|
|
GIT_TRACE_REDACT=0 \
|
|
|
|
|
git -c protocol.version=2 \
|
|
|
|
|
-c fetch.uriprotocols=http,https \
|
|
|
|
|
clone "$HTTPD_URL/smart/http_parent" http_child &&
|
|
|
|
|
|
|
|
|
|
grep -F "clone< \\1$(cat packh) $HTTPD_URL/dumb/mypack-$(cat packh).pack" log
|
|
|
|
|
'
|
|
|
|
|
|
fetch: teach independent negotiation (no packfile)
Currently, the packfile negotiation step within a Git fetch cannot be
done independent of sending the packfile, even though there is at least
one application wherein this is useful. Therefore, make it possible for
this negotiation step to be done independently. A subsequent commit will
use this for one such application - push negotiation.
This feature is for protocol v2 only. (An implementation for protocol v0
would require a separate implementation in the fetch, transport, and
transport helper code.)
In the protocol, the main hindrance towards independent negotiation is
that the server can unilaterally decide to send the packfile. This is
solved by a "wait-for-done" argument: the server will then wait for the
client to say "done". In practice, the client will never say it; instead
it will cease requests once it is satisfied.
In the client, the main change lies in the transport and transport
helper code. fetch_refs_via_pack() performs everything needed - protocol
version and capability checks, and the negotiation itself.
There are 2 code paths that do not go through fetch_refs_via_pack() that
needed to be individually excluded: the bundle transport (excluded
through requiring smart_options, which the bundle transport doesn't
support) and transport helpers that do not support takeover. If or when
we support independent negotiation for protocol v0, we will need to
modify these 2 code paths to support it. But for now, report failure if
independent negotiation is requested in these cases.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-05-04 21:16:01 +00:00
|
|
|
test_expect_success 'http:// --negotiate-only' '
|
|
|
|
|
SERVER="$HTTPD_DOCUMENT_ROOT_PATH/server" &&
|
|
|
|
|
URI="$HTTPD_URL/smart/server" &&
|
|
|
|
|
|
|
|
|
|
setup_negotiate_only "$SERVER" "$URI" &&
|
|
|
|
|
|
|
|
|
|
git -c protocol.version=2 -C client fetch \
|
|
|
|
|
--no-tags \
|
|
|
|
|
--negotiate-only \
|
|
|
|
|
--negotiation-tip=$(git -C client rev-parse HEAD) \
|
|
|
|
|
origin >out &&
|
|
|
|
|
COMMON=$(git -C "$SERVER" rev-parse two) &&
|
|
|
|
|
grep "$COMMON" out
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'http:// --negotiate-only without wait-for-done support' '
|
|
|
|
|
SERVER="server" &&
|
|
|
|
|
URI="$HTTPD_URL/one_time_perl/server" &&
|
|
|
|
|
|
|
|
|
|
setup_negotiate_only "$SERVER" "$URI" &&
|
|
|
|
|
|
|
|
|
|
echo "s/ wait-for-done/ xxxx-xxx-xxxx/" \
|
|
|
|
|
>"$HTTPD_ROOT_PATH/one-time-perl" &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git -c protocol.version=2 -C client fetch \
|
|
|
|
|
--no-tags \
|
|
|
|
|
--negotiate-only \
|
|
|
|
|
--negotiation-tip=$(git -C client rev-parse HEAD) \
|
|
|
|
|
origin 2>err &&
|
|
|
|
|
test_i18ngrep "server does not support wait-for-done" err
|
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
test_expect_success 'http:// --negotiate-only with protocol v0' '
|
|
|
|
|
SERVER="$HTTPD_DOCUMENT_ROOT_PATH/server" &&
|
|
|
|
|
URI="$HTTPD_URL/smart/server" &&
|
|
|
|
|
|
|
|
|
|
setup_negotiate_only "$SERVER" "$URI" &&
|
|
|
|
|
|
|
|
|
|
test_must_fail git -c protocol.version=0 -C client fetch \
|
|
|
|
|
--no-tags \
|
|
|
|
|
--negotiate-only \
|
|
|
|
|
--negotiation-tip=$(git -C client rev-parse HEAD) \
|
|
|
|
|
origin 2>err &&
|
|
|
|
|
test_i18ngrep "negotiate-only requires protocol v2" err
|
|
|
|
|
'
|
|
|
|
|
|
2019-08-01 15:53:09 +00:00
|
|
|
# DO NOT add non-httpd-specific tests here, because the last part of this
|
|
|
|
|
# test script is only executed when httpd is available and enabled.
|
|
|
|
|
|
2018-03-15 17:31:21 +00:00
|
|
|
test_done
|