2005-06-23 01:49:43 +00:00
|
|
|
#!/bin/sh
|
2005-07-06 20:04:21 +00:00
|
|
|
#
|
|
|
|
# Copyright (c) 2005, Linus Torvalds
|
|
|
|
# Copyright (c) 2005, Junio C Hamano
|
2007-06-07 07:04:01 +00:00
|
|
|
#
|
2005-07-06 20:04:21 +00:00
|
|
|
# Clone a repository into a different directory that does not yet exist.
|
|
|
|
|
2005-09-13 02:47:07 +00:00
|
|
|
# See git-sh-setup why.
|
|
|
|
unset CDPATH
|
|
|
|
|
2006-10-20 19:38:31 +00:00
|
|
|
die() {
|
|
|
|
echo >&2 "$@"
|
2005-07-06 20:04:21 +00:00
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
|
2006-10-20 19:38:31 +00:00
|
|
|
usage() {
|
2006-12-27 10:43:46 +00:00
|
|
|
die "Usage: $0 [--template=<template_directory>] [--reference <reference-repo>] [--bare] [-l [-s]] [-q] [-u <upload-pack>] [--origin <name>] [--depth <n>] [-n] <repo> [<dir>]"
|
2006-10-20 19:38:31 +00:00
|
|
|
}
|
|
|
|
|
2005-07-08 22:46:33 +00:00
|
|
|
get_repo_base() {
|
2007-05-10 00:11:15 +00:00
|
|
|
(
|
|
|
|
cd "`/bin/pwd`" &&
|
2007-06-06 23:39:05 +00:00
|
|
|
cd "$1" || cd "$1.git" &&
|
2007-05-10 00:11:15 +00:00
|
|
|
{
|
2007-05-14 21:24:02 +00:00
|
|
|
cd .git
|
2007-05-10 00:11:15 +00:00
|
|
|
pwd
|
|
|
|
}
|
2007-05-14 21:24:02 +00:00
|
|
|
) 2>/dev/null
|
2005-07-08 22:46:33 +00:00
|
|
|
}
|
|
|
|
|
2007-10-28 17:47:30 +00:00
|
|
|
if [ -n "$GIT_SSL_NO_VERIFY" -o \
|
|
|
|
"`git config --bool http.sslVerify`" = false ]; then
|
2005-09-05 07:47:39 +00:00
|
|
|
curl_extra_args="-k"
|
|
|
|
fi
|
|
|
|
|
|
|
|
http_fetch () {
|
|
|
|
# $1 = Remote, $2 = Local
|
2007-09-13 11:36:22 +00:00
|
|
|
curl -nsfL $curl_extra_args "$1" >"$2" ||
|
|
|
|
case $? in
|
|
|
|
126|127) exit ;;
|
|
|
|
*) return $? ;;
|
|
|
|
esac
|
2005-09-05 07:47:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
clone_dumb_http () {
|
|
|
|
# $1 - remote, $2 - local
|
|
|
|
cd "$2" &&
|
2006-06-10 08:12:50 +00:00
|
|
|
clone_tmp="$GIT_DIR/clone-tmp" &&
|
2005-09-05 07:47:39 +00:00
|
|
|
mkdir -p "$clone_tmp" || exit 1
|
2006-09-29 00:10:44 +00:00
|
|
|
if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
|
2007-07-03 05:52:14 +00:00
|
|
|
"`git config --bool http.noEPSV`" = true ]; then
|
2006-09-29 00:10:44 +00:00
|
|
|
curl_extra_args="${curl_extra_args} --disable-epsv"
|
|
|
|
fi
|
2006-10-20 19:38:31 +00:00
|
|
|
http_fetch "$1/info/refs" "$clone_tmp/refs" ||
|
|
|
|
die "Cannot get remote repository information.
|
2005-09-05 07:47:39 +00:00
|
|
|
Perhaps git-update-server-info needs to be run there?"
|
2007-03-20 02:18:18 +00:00
|
|
|
test "z$quiet" = z && v=-v || v=
|
2005-09-05 07:47:39 +00:00
|
|
|
while read sha1 refname
|
|
|
|
do
|
2006-04-13 22:01:24 +00:00
|
|
|
name=`expr "z$refname" : 'zrefs/\(.*\)'` &&
|
2005-10-18 04:47:06 +00:00
|
|
|
case "$name" in
|
2006-03-20 08:21:10 +00:00
|
|
|
*^*) continue;;
|
2005-10-18 04:47:06 +00:00
|
|
|
esac
|
2006-11-25 03:07:24 +00:00
|
|
|
case "$bare,$name" in
|
|
|
|
yes,* | ,heads/* | ,tags/*) ;;
|
|
|
|
*) continue ;;
|
|
|
|
esac
|
2006-03-20 08:21:10 +00:00
|
|
|
if test -n "$use_separate_remote" &&
|
2006-04-13 22:01:24 +00:00
|
|
|
branch_name=`expr "z$name" : 'zheads/\(.*\)'`
|
2006-03-20 08:21:10 +00:00
|
|
|
then
|
2006-03-21 09:58:26 +00:00
|
|
|
tname="remotes/$origin/$branch_name"
|
2006-03-20 08:21:10 +00:00
|
|
|
else
|
|
|
|
tname=$name
|
|
|
|
fi
|
2007-04-21 00:25:27 +00:00
|
|
|
git-http-fetch $v -a -w "$tname" "$sha1" "$1" || exit 1
|
2005-09-05 07:47:39 +00:00
|
|
|
done <"$clone_tmp/refs"
|
|
|
|
rm -fr "$clone_tmp"
|
git-clone: fix handling of upsteram whose HEAD does not point at master.
When cloning from a remote repository that has master, main, and
origin branches _and_ with the HEAD pointing at main branch, we
did quite confused things during clone. So this cleans things
up. The behaviour is a bit different between separate remotes/
layout and the mixed branches layout.
The newer layout with $GIT_DIR/refs/remotes/$origin/, things are
simpler and more transparent:
- remote branches are copied to refs/remotes/$origin/.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches, and merge the branch HEAD pointed at at the time of
the cloning.
Everything-in-refs/heads layout was the more confused one, but
cleaned up like this:
- remote branches are copied to refs/heads, but the branch
"$origin" is not copied, instead a copy of the branch the
remote HEAD points at is created there.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches except "$origin", and merge the branch HEAD pointed
at at the time of the cloning.
With this, the remote has master, main and origin, and its HEAD
points at main, you could:
git clone $URL --origin upstream
to use refs/heads/upstream as the tracking branch for remote
"main", and your primary working branch will also be "main".
"master" and "origin" are used to track the corresponding remote
branches and with this setup they do not have any special meaning.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-02 23:25:01 +00:00
|
|
|
http_fetch "$1/HEAD" "$GIT_DIR/REMOTE_HEAD" ||
|
|
|
|
rm -f "$GIT_DIR/REMOTE_HEAD"
|
2007-06-29 08:31:08 +00:00
|
|
|
if test -f "$GIT_DIR/REMOTE_HEAD"; then
|
|
|
|
head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"`
|
|
|
|
case "$head_sha1" in
|
|
|
|
'ref: refs/'*)
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
git-http-fetch $v -a "$head_sha1" "$1" ||
|
|
|
|
rm -f "$GIT_DIR/REMOTE_HEAD"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
fi
|
2006-03-20 08:21:10 +00:00
|
|
|
}
|
|
|
|
|
2005-07-09 17:52:35 +00:00
|
|
|
quiet=
|
2006-03-30 17:01:23 +00:00
|
|
|
local=no
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
use_local_hardlink=yes
|
2005-08-15 00:25:57 +00:00
|
|
|
local_shared=no
|
2006-05-28 17:14:38 +00:00
|
|
|
unset template
|
2005-09-27 00:17:09 +00:00
|
|
|
no_checkout=
|
2005-07-14 03:25:54 +00:00
|
|
|
upload_pack=
|
2006-01-23 01:24:22 +00:00
|
|
|
bare=
|
2006-03-20 08:21:10 +00:00
|
|
|
reference=
|
|
|
|
origin=
|
2006-01-23 01:28:49 +00:00
|
|
|
origin_override=
|
2006-11-23 22:58:35 +00:00
|
|
|
use_separate_remote=t
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
depth=
|
2007-02-20 02:01:44 +00:00
|
|
|
no_progress=
|
2007-08-20 22:35:15 +00:00
|
|
|
local_explicitly_asked_for=
|
2007-02-20 02:01:44 +00:00
|
|
|
test -t 1 || no_progress=--no-progress
|
2005-07-06 20:04:21 +00:00
|
|
|
while
|
|
|
|
case "$#,$1" in
|
|
|
|
0,*) break ;;
|
2006-01-15 00:00:32 +00:00
|
|
|
*,-n|*,--no|*,--no-|*,--no-c|*,--no-ch|*,--no-che|*,--no-chec|\
|
|
|
|
*,--no-check|*,--no-checko|*,--no-checkou|*,--no-checkout)
|
|
|
|
no_checkout=yes ;;
|
2006-01-23 01:24:22 +00:00
|
|
|
*,--na|*,--nak|*,--nake|*,--naked|\
|
|
|
|
*,-b|*,--b|*,--ba|*,--bar|*,--bare) bare=yes ;;
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
*,-l|*,--l|*,--lo|*,--loc|*,--loca|*,--local)
|
2007-08-20 22:35:15 +00:00
|
|
|
local_explicitly_asked_for=yes
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
use_local_hardlink=yes ;;
|
|
|
|
*,--no-h|*,--no-ha|*,--no-har|*,--no-hard|*,--no-hardl|\
|
|
|
|
*,--no-hardli|*,--no-hardlin|*,--no-hardlink|*,--no-hardlinks)
|
|
|
|
use_local_hardlink=no ;;
|
2007-06-07 07:04:01 +00:00
|
|
|
*,-s|*,--s|*,--sh|*,--sha|*,--shar|*,--share|*,--shared)
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
local_shared=yes; ;;
|
2006-05-28 17:14:38 +00:00
|
|
|
1,--template) usage ;;
|
|
|
|
*,--template)
|
|
|
|
shift; template="--template=$1" ;;
|
|
|
|
*,--template=*)
|
|
|
|
template="$1" ;;
|
2005-07-09 17:52:35 +00:00
|
|
|
*,-q|*,--quiet) quiet=-q ;;
|
2006-12-16 09:53:10 +00:00
|
|
|
*,--use-separate-remote) ;;
|
2006-12-04 13:29:09 +00:00
|
|
|
*,--no-separate-remote)
|
2006-12-16 09:53:10 +00:00
|
|
|
die "clones are always made with separate-remote layout" ;;
|
2006-03-20 08:21:10 +00:00
|
|
|
1,--reference) usage ;;
|
|
|
|
*,--reference)
|
|
|
|
shift; reference="$1" ;;
|
|
|
|
*,--reference=*)
|
2006-06-27 16:54:26 +00:00
|
|
|
reference=`expr "z$1" : 'z--reference=\(.*\)'` ;;
|
2006-03-30 17:00:43 +00:00
|
|
|
*,-o|*,--or|*,--ori|*,--orig|*,--origi|*,--origin)
|
2006-03-21 08:14:13 +00:00
|
|
|
case "$2" in
|
2006-03-30 17:00:43 +00:00
|
|
|
'')
|
|
|
|
usage ;;
|
2006-03-21 08:14:13 +00:00
|
|
|
*/*)
|
2006-10-20 19:38:31 +00:00
|
|
|
die "'$2' is not suitable for an origin name"
|
2006-03-21 08:14:13 +00:00
|
|
|
esac
|
2007-07-03 05:52:14 +00:00
|
|
|
git check-ref-format "heads/$2" ||
|
2006-10-20 19:38:31 +00:00
|
|
|
die "'$2' is not suitable for a branch name"
|
|
|
|
test -z "$origin_override" ||
|
|
|
|
die "Do not give more than one --origin options."
|
2006-01-23 01:28:49 +00:00
|
|
|
origin_override=yes
|
2005-12-22 22:37:24 +00:00
|
|
|
origin="$2"; shift
|
|
|
|
;;
|
2005-07-23 02:11:22 +00:00
|
|
|
1,-u|1,--upload-pack) usage ;;
|
2005-07-14 03:25:54 +00:00
|
|
|
*,-u|*,--upload-pack)
|
|
|
|
shift
|
2007-01-23 08:51:53 +00:00
|
|
|
upload_pack="--upload-pack=$1" ;;
|
|
|
|
*,--upload-pack=*)
|
2007-01-30 18:11:49 +00:00
|
|
|
upload_pack=--upload-pack=$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
1,--depth) usage;;
|
|
|
|
*,--depth)
|
|
|
|
shift
|
|
|
|
depth="--depth=$1";;
|
2005-07-06 20:04:21 +00:00
|
|
|
*,-*) usage ;;
|
|
|
|
*) break ;;
|
|
|
|
esac
|
|
|
|
do
|
|
|
|
shift
|
|
|
|
done
|
|
|
|
|
2006-03-30 17:01:23 +00:00
|
|
|
repo="$1"
|
2006-10-20 19:38:31 +00:00
|
|
|
test -n "$repo" ||
|
|
|
|
die 'you must specify a repository to clone.'
|
2006-03-30 17:01:23 +00:00
|
|
|
|
2006-12-04 13:29:09 +00:00
|
|
|
# --bare implies --no-checkout and --no-separate-remote
|
2006-01-23 01:28:49 +00:00
|
|
|
if test yes = "$bare"
|
|
|
|
then
|
|
|
|
if test yes = "$origin_override"
|
|
|
|
then
|
2006-10-20 19:38:31 +00:00
|
|
|
die '--bare and --origin $origin options are incompatible.'
|
2006-01-23 01:28:49 +00:00
|
|
|
fi
|
|
|
|
no_checkout=yes
|
2006-11-23 22:58:35 +00:00
|
|
|
use_separate_remote=
|
2006-01-23 01:28:49 +00:00
|
|
|
fi
|
2006-01-15 00:00:32 +00:00
|
|
|
|
2006-03-21 08:14:13 +00:00
|
|
|
if test -z "$origin"
|
2006-03-20 08:21:10 +00:00
|
|
|
then
|
2006-03-21 08:14:13 +00:00
|
|
|
origin=origin
|
2006-03-20 08:21:10 +00:00
|
|
|
fi
|
|
|
|
|
2005-07-08 22:46:33 +00:00
|
|
|
# Turn the source into an absolute path if
|
|
|
|
# it is local
|
|
|
|
if base=$(get_repo_base "$repo"); then
|
|
|
|
repo="$base"
|
|
|
|
local=yes
|
|
|
|
fi
|
|
|
|
|
2005-06-23 01:49:43 +00:00
|
|
|
dir="$2"
|
2005-11-10 11:58:08 +00:00
|
|
|
# Try using "humanish" part of source repo if user didn't specify one
|
2006-01-20 06:47:39 +00:00
|
|
|
[ -z "$dir" ] && dir=$(echo "$repo" | sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
|
2006-10-20 19:38:31 +00:00
|
|
|
[ -e "$dir" ] && die "destination directory '$dir' already exists."
|
2007-07-05 23:10:44 +00:00
|
|
|
[ yes = "$bare" ] && unset GIT_WORK_TREE
|
|
|
|
[ -n "$GIT_WORK_TREE" ] && [ -e "$GIT_WORK_TREE" ] &&
|
|
|
|
die "working tree '$GIT_WORK_TREE' already exists."
|
2007-07-05 22:54:33 +00:00
|
|
|
D=
|
2007-07-05 23:10:44 +00:00
|
|
|
W=
|
2007-07-05 22:54:33 +00:00
|
|
|
cleanup() {
|
|
|
|
err=$?
|
|
|
|
test -z "$D" && rm -rf "$dir"
|
2007-07-05 23:10:44 +00:00
|
|
|
test -z "$W" && test -n "$GIT_WORK_TREE" && rm -rf "$GIT_WORK_TREE"
|
2007-07-05 22:54:33 +00:00
|
|
|
cd ..
|
|
|
|
test -n "$D" && rm -rf "$D"
|
2007-07-05 23:10:44 +00:00
|
|
|
test -n "$W" && rm -rf "$W"
|
2007-07-05 22:54:33 +00:00
|
|
|
exit $err
|
|
|
|
}
|
|
|
|
trap cleanup 0
|
|
|
|
mkdir -p "$dir" && D=$(cd "$dir" && pwd) || usage
|
2007-07-05 23:10:44 +00:00
|
|
|
test -n "$GIT_WORK_TREE" && mkdir -p "$GIT_WORK_TREE" &&
|
|
|
|
W=$(cd "$GIT_WORK_TREE" && pwd) && export GIT_WORK_TREE="$W"
|
|
|
|
if test yes = "$bare" || test -n "$GIT_WORK_TREE"; then
|
|
|
|
GIT_DIR="$D"
|
|
|
|
else
|
|
|
|
GIT_DIR="$D/.git"
|
|
|
|
fi &&
|
2007-07-05 22:54:33 +00:00
|
|
|
export GIT_DIR &&
|
2007-08-16 03:55:44 +00:00
|
|
|
GIT_CONFIG="$GIT_DIR/config" git-init $quiet ${template+"$template"} || usage
|
|
|
|
|
|
|
|
if test -n "$bare"
|
|
|
|
then
|
|
|
|
GIT_CONFIG="$GIT_DIR/config" git config core.bare true
|
|
|
|
fi
|
2005-07-06 20:04:21 +00:00
|
|
|
|
2006-03-20 08:21:10 +00:00
|
|
|
if test -n "$reference"
|
|
|
|
then
|
2007-02-07 10:10:56 +00:00
|
|
|
ref_git=
|
2006-03-20 08:21:10 +00:00
|
|
|
if test -d "$reference"
|
|
|
|
then
|
|
|
|
if test -d "$reference/.git/objects"
|
|
|
|
then
|
2007-02-07 10:10:56 +00:00
|
|
|
ref_git="$reference/.git"
|
|
|
|
elif test -d "$reference/objects"
|
|
|
|
then
|
|
|
|
ref_git="$reference"
|
2006-03-20 08:21:10 +00:00
|
|
|
fi
|
2007-02-07 10:10:56 +00:00
|
|
|
fi
|
|
|
|
if test -n "$ref_git"
|
|
|
|
then
|
|
|
|
ref_git=$(cd "$ref_git" && pwd)
|
|
|
|
echo "$ref_git/objects" >"$GIT_DIR/objects/info/alternates"
|
|
|
|
(
|
|
|
|
GIT_DIR="$ref_git" git for-each-ref \
|
|
|
|
--format='%(objectname) %(*objectname)'
|
|
|
|
) |
|
|
|
|
while read a b
|
|
|
|
do
|
|
|
|
test -z "$a" ||
|
|
|
|
git update-ref "refs/reference-tmp/$a" "$a"
|
|
|
|
test -z "$b" ||
|
|
|
|
git update-ref "refs/reference-tmp/$b" "$b"
|
|
|
|
done
|
2006-03-20 08:21:10 +00:00
|
|
|
else
|
2006-10-20 19:38:31 +00:00
|
|
|
die "reference repository '$reference' is not a local directory."
|
2006-03-20 08:21:10 +00:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
|
|
rm -f "$GIT_DIR/CLONE_HEAD"
|
|
|
|
|
2005-07-06 20:04:21 +00:00
|
|
|
# We do local magic only when the user tells us to.
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
case "$local" in
|
|
|
|
yes)
|
2006-10-20 19:38:31 +00:00
|
|
|
( cd "$repo/objects" ) ||
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
die "cannot chdir to local '$repo/objects'."
|
2005-07-06 20:04:21 +00:00
|
|
|
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
if test "$local_shared" = yes
|
|
|
|
then
|
|
|
|
mkdir -p "$GIT_DIR/objects/info"
|
|
|
|
echo "$repo/objects" >>"$GIT_DIR/objects/info/alternates"
|
|
|
|
else
|
|
|
|
l= &&
|
|
|
|
if test "$use_local_hardlink" = yes
|
|
|
|
then
|
|
|
|
# See if we can hardlink and drop "l" if not.
|
|
|
|
sample_file=$(cd "$repo" && \
|
|
|
|
find objects -type f -print | sed -e 1q)
|
|
|
|
# objects directory should not be empty because
|
|
|
|
# we are cloning!
|
|
|
|
test -f "$repo/$sample_file" || exit
|
|
|
|
if ln "$repo/$sample_file" "$GIT_DIR/objects/sample" 2>/dev/null
|
|
|
|
then
|
|
|
|
rm -f "$GIT_DIR/objects/sample"
|
|
|
|
l=l
|
2007-08-20 22:35:15 +00:00
|
|
|
elif test -n "$local_explicitly_asked_for"
|
|
|
|
then
|
git-clone: aggressively optimize local clone behaviour.
This changes the behaviour of cloning from a repository on the
local machine, by defaulting to "-l" (use hardlinks to share
files under .git/objects) and making "-l" a no-op. A new
option, --no-hardlinks, is also added to cause file-level copy
of files under .git/objects while still avoiding the normal
"pack to pipe, then receive and index pack" network transfer
overhead. The old behaviour of local cloning without -l nor -s
is availble by specifying the source repository with the newly
introduced file:///path/to/repo.git/ syntax (i.e. "same as
network" cloning).
* With --no-hardlinks (i.e. have all .git/objects/ copied via
cpio) would not catch the source repository corruption, and
also risks corrupted recipient repository if an
alpha-particle hits memory cell while indexing and resolving
deltas. As long as the recipient is created uncorrupted, you
have a good back-up.
* same-as-network is expensive, but it would catch the breakage
of the source repository. It still risks corrupted recipient
repository due to hardware failure. As long as the recipient
is created uncorrupted, you have a good back-up.
* The new default on the same filesystem, as long as the source
repository is healthy, it is very likely that the recipient
would be, too. Also it is very cheap. You do not get any
back-up benefit, though.
None of the method is resilient against the source repository
corruption, so let's discount that from the comparison. Then
the difference with and without --no-hardlinks matters primarily
if you value the back-up benefit or not. If you want to use the
cloned repository as a back-up, then it is cheaper to do a clone
with --no-hardlinks and two git-fsck (source before clone,
recipient after clone) than same-as-network clone, especially as
you are likely to do a git-fsck on the recipient if you are so
paranoid anyway.
Which leads me to believe that being able to use file:/// is
probably a good idea, if only for testability, but probably of
little practical value. We default to hardlinked clone for
everyday use, and paranoids can use --no-hardlinks as a way to
make a back-up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-02 06:42:36 +00:00
|
|
|
echo >&2 "Warning: -l asked but cannot hardlink to $repo"
|
|
|
|
fi
|
|
|
|
fi &&
|
|
|
|
cd "$repo" &&
|
|
|
|
find objects -depth -print | cpio -pumd$l "$GIT_DIR/" || exit 1
|
|
|
|
fi
|
2006-07-10 10:34:34 +00:00
|
|
|
git-ls-remote "$repo" >"$GIT_DIR/CLONE_HEAD" || exit 1
|
2005-07-09 00:07:12 +00:00
|
|
|
;;
|
|
|
|
*)
|
2005-07-23 02:11:22 +00:00
|
|
|
case "$repo" in
|
|
|
|
rsync://*)
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
case "$depth" in
|
|
|
|
"") ;;
|
|
|
|
*) die "shallow over rsync not supported" ;;
|
|
|
|
esac
|
2005-09-17 18:56:41 +00:00
|
|
|
rsync $quiet -av --ignore-existing \
|
2006-03-20 08:21:10 +00:00
|
|
|
--exclude info "$repo/objects/" "$GIT_DIR/objects/" ||
|
|
|
|
exit
|
2005-09-17 18:56:41 +00:00
|
|
|
# Look at objects/info/alternates for rsync -- http will
|
|
|
|
# support it natively and git native ones will do it on the
|
|
|
|
# remote end. Not having that file is not a crime.
|
2005-09-20 06:52:33 +00:00
|
|
|
rsync -q "$repo/objects/info/alternates" \
|
2006-01-15 00:00:32 +00:00
|
|
|
"$GIT_DIR/TMP_ALT" 2>/dev/null ||
|
|
|
|
rm -f "$GIT_DIR/TMP_ALT"
|
|
|
|
if test -f "$GIT_DIR/TMP_ALT"
|
2005-09-17 18:56:41 +00:00
|
|
|
then
|
2005-11-11 05:19:04 +00:00
|
|
|
( cd "$D" &&
|
2005-09-17 18:56:41 +00:00
|
|
|
. git-parse-remote &&
|
2006-01-15 00:00:32 +00:00
|
|
|
resolve_alternates "$repo" <"$GIT_DIR/TMP_ALT" ) |
|
2005-09-17 18:56:41 +00:00
|
|
|
while read alt
|
|
|
|
do
|
|
|
|
case "$alt" in 'bad alternate: '*) die "$alt";; esac
|
|
|
|
case "$quiet" in
|
|
|
|
'') echo >&2 "Getting alternate: $alt" ;;
|
|
|
|
esac
|
|
|
|
rsync $quiet -av --ignore-existing \
|
2006-01-15 00:00:32 +00:00
|
|
|
--exclude info "$alt" "$GIT_DIR/objects" || exit
|
2005-09-17 18:56:41 +00:00
|
|
|
done
|
2006-01-15 00:00:32 +00:00
|
|
|
rm -f "$GIT_DIR/TMP_ALT"
|
2005-09-17 18:56:41 +00:00
|
|
|
fi
|
2006-07-10 10:34:34 +00:00
|
|
|
git-ls-remote "$repo" >"$GIT_DIR/CLONE_HEAD" || exit 1
|
2005-07-23 02:11:22 +00:00
|
|
|
;;
|
2006-09-14 02:24:04 +00:00
|
|
|
https://*|http://*|ftp://*)
|
allow cloning a repository "shallowly"
By specifying a depth, you can now clone a repository such that
all fetched ancestor-chains' length is at most "depth". For example,
if the upstream repository has only 2 branches ("A" and "B"), which
are linear, and you specify depth 3, you will get A, A~1, A~2, A~3,
B, B~1, B~2, and B~3. The ends are automatically made shallow
commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-10-30 19:09:29 +00:00
|
|
|
case "$depth" in
|
|
|
|
"") ;;
|
|
|
|
*) die "shallow over http or ftp not supported" ;;
|
|
|
|
esac
|
2006-02-15 11:37:30 +00:00
|
|
|
if test -z "@@NO_CURL@@"
|
|
|
|
then
|
|
|
|
clone_dumb_http "$repo" "$D"
|
|
|
|
else
|
2006-10-20 19:38:31 +00:00
|
|
|
die "http transport not supported, rebuild Git with curl support"
|
2006-02-15 11:37:30 +00:00
|
|
|
fi
|
2005-07-23 02:11:22 +00:00
|
|
|
;;
|
|
|
|
*)
|
2006-10-14 12:02:51 +00:00
|
|
|
case "$upload_pack" in
|
2007-02-20 02:01:44 +00:00
|
|
|
'') git-fetch-pack --all -k $quiet $depth $no_progress "$repo";;
|
|
|
|
*) git-fetch-pack --all -k $quiet "$upload_pack" $depth $no_progress "$repo" ;;
|
2006-10-20 19:38:31 +00:00
|
|
|
esac >"$GIT_DIR/CLONE_HEAD" ||
|
|
|
|
die "fetch-pack from '$repo' failed."
|
2005-07-23 02:11:22 +00:00
|
|
|
;;
|
2005-07-14 03:25:54 +00:00
|
|
|
esac
|
2005-07-09 00:07:12 +00:00
|
|
|
;;
|
|
|
|
esac
|
2006-03-20 08:21:10 +00:00
|
|
|
test -d "$GIT_DIR/refs/reference-tmp" && rm -fr "$GIT_DIR/refs/reference-tmp"
|
|
|
|
|
|
|
|
if test -f "$GIT_DIR/CLONE_HEAD"
|
|
|
|
then
|
git-clone: fix handling of upsteram whose HEAD does not point at master.
When cloning from a remote repository that has master, main, and
origin branches _and_ with the HEAD pointing at main branch, we
did quite confused things during clone. So this cleans things
up. The behaviour is a bit different between separate remotes/
layout and the mixed branches layout.
The newer layout with $GIT_DIR/refs/remotes/$origin/, things are
simpler and more transparent:
- remote branches are copied to refs/remotes/$origin/.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches, and merge the branch HEAD pointed at at the time of
the cloning.
Everything-in-refs/heads layout was the more confused one, but
cleaned up like this:
- remote branches are copied to refs/heads, but the branch
"$origin" is not copied, instead a copy of the branch the
remote HEAD points at is created there.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches except "$origin", and merge the branch HEAD pointed
at at the time of the cloning.
With this, the remote has master, main and origin, and its HEAD
points at main, you could:
git clone $URL --origin upstream
to use refs/heads/upstream as the tracking branch for remote
"main", and your primary working branch will also be "main".
"master" and "origin" are used to track the corresponding remote
branches and with this setup they do not have any special meaning.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-02 23:25:01 +00:00
|
|
|
# Read git-fetch-pack -k output and store the remote branches.
|
2007-01-29 08:09:25 +00:00
|
|
|
if [ -n "$use_separate_remote" ]
|
|
|
|
then
|
|
|
|
branch_top="remotes/$origin"
|
|
|
|
else
|
|
|
|
branch_top="heads"
|
|
|
|
fi
|
|
|
|
tag_top="tags"
|
|
|
|
while read sha1 name
|
|
|
|
do
|
|
|
|
case "$name" in
|
|
|
|
*'^{}')
|
|
|
|
continue ;;
|
|
|
|
HEAD)
|
|
|
|
destname="REMOTE_HEAD" ;;
|
|
|
|
refs/heads/*)
|
|
|
|
destname="refs/$branch_top/${name#refs/heads/}" ;;
|
|
|
|
refs/tags/*)
|
|
|
|
destname="refs/$tag_top/${name#refs/tags/}" ;;
|
|
|
|
*)
|
|
|
|
continue ;;
|
|
|
|
esac
|
2007-07-03 05:52:14 +00:00
|
|
|
git update-ref -m "clone: from $repo" "$destname" "$sha1" ""
|
2007-01-29 08:09:25 +00:00
|
|
|
done < "$GIT_DIR/CLONE_HEAD"
|
2006-03-20 08:21:10 +00:00
|
|
|
fi
|
2005-07-23 02:11:22 +00:00
|
|
|
|
2007-07-05 23:10:44 +00:00
|
|
|
if test -n "$W"; then
|
|
|
|
cd "$W" || exit
|
|
|
|
else
|
|
|
|
cd "$D" || exit
|
|
|
|
fi
|
2005-09-27 00:17:09 +00:00
|
|
|
|
2006-03-20 08:21:10 +00:00
|
|
|
if test -z "$bare" && test -f "$GIT_DIR/REMOTE_HEAD"
|
2005-09-27 00:17:09 +00:00
|
|
|
then
|
2006-12-16 09:53:10 +00:00
|
|
|
# a non-bare repository is always in separate-remote layout
|
|
|
|
remote_top="refs/remotes/$origin"
|
git-clone: fix handling of upsteram whose HEAD does not point at master.
When cloning from a remote repository that has master, main, and
origin branches _and_ with the HEAD pointing at main branch, we
did quite confused things during clone. So this cleans things
up. The behaviour is a bit different between separate remotes/
layout and the mixed branches layout.
The newer layout with $GIT_DIR/refs/remotes/$origin/, things are
simpler and more transparent:
- remote branches are copied to refs/remotes/$origin/.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches, and merge the branch HEAD pointed at at the time of
the cloning.
Everything-in-refs/heads layout was the more confused one, but
cleaned up like this:
- remote branches are copied to refs/heads, but the branch
"$origin" is not copied, instead a copy of the branch the
remote HEAD points at is created there.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches except "$origin", and merge the branch HEAD pointed
at at the time of the cloning.
With this, the remote has master, main and origin, and its HEAD
points at main, you could:
git clone $URL --origin upstream
to use refs/heads/upstream as the tracking branch for remote
"main", and your primary working branch will also be "main".
"master" and "origin" are used to track the corresponding remote
branches and with this setup they do not have any special meaning.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-02 23:25:01 +00:00
|
|
|
head_sha1=`cat "$GIT_DIR/REMOTE_HEAD"`
|
|
|
|
case "$head_sha1" in
|
|
|
|
'ref: refs/'*)
|
|
|
|
# Uh-oh, the remote told us (http transport done against
|
|
|
|
# new style repository with a symref HEAD).
|
|
|
|
# Ideally we should skip the guesswork but for now
|
|
|
|
# opt for minimum change.
|
2006-04-13 22:01:24 +00:00
|
|
|
head_sha1=`expr "z$head_sha1" : 'zref: refs/heads/\(.*\)'`
|
git-clone: fix handling of upsteram whose HEAD does not point at master.
When cloning from a remote repository that has master, main, and
origin branches _and_ with the HEAD pointing at main branch, we
did quite confused things during clone. So this cleans things
up. The behaviour is a bit different between separate remotes/
layout and the mixed branches layout.
The newer layout with $GIT_DIR/refs/remotes/$origin/, things are
simpler and more transparent:
- remote branches are copied to refs/remotes/$origin/.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches, and merge the branch HEAD pointed at at the time of
the cloning.
Everything-in-refs/heads layout was the more confused one, but
cleaned up like this:
- remote branches are copied to refs/heads, but the branch
"$origin" is not copied, instead a copy of the branch the
remote HEAD points at is created there.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches except "$origin", and merge the branch HEAD pointed
at at the time of the cloning.
With this, the remote has master, main and origin, and its HEAD
points at main, you could:
git clone $URL --origin upstream
to use refs/heads/upstream as the tracking branch for remote
"main", and your primary working branch will also be "main".
"master" and "origin" are used to track the corresponding remote
branches and with this setup they do not have any special meaning.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-02 23:25:01 +00:00
|
|
|
head_sha1=`cat "$GIT_DIR/$remote_top/$head_sha1"`
|
|
|
|
;;
|
|
|
|
esac
|
2006-03-21 08:14:13 +00:00
|
|
|
|
git-clone: fix handling of upsteram whose HEAD does not point at master.
When cloning from a remote repository that has master, main, and
origin branches _and_ with the HEAD pointing at main branch, we
did quite confused things during clone. So this cleans things
up. The behaviour is a bit different between separate remotes/
layout and the mixed branches layout.
The newer layout with $GIT_DIR/refs/remotes/$origin/, things are
simpler and more transparent:
- remote branches are copied to refs/remotes/$origin/.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches, and merge the branch HEAD pointed at at the time of
the cloning.
Everything-in-refs/heads layout was the more confused one, but
cleaned up like this:
- remote branches are copied to refs/heads, but the branch
"$origin" is not copied, instead a copy of the branch the
remote HEAD points at is created there.
- HEAD points at the branch with the same name as the remote
HEAD points at, and starts at where the remote HEAD points at.
- $GIT_DIR/remotes/$origin file is set up to fetch all remote
branches except "$origin", and merge the branch HEAD pointed
at at the time of the cloning.
With this, the remote has master, main and origin, and its HEAD
points at main, you could:
git clone $URL --origin upstream
to use refs/heads/upstream as the tracking branch for remote
"main", and your primary working branch will also be "main".
"master" and "origin" are used to track the corresponding remote
branches and with this setup they do not have any special meaning.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-02 23:25:01 +00:00
|
|
|
# The name under $remote_top the remote HEAD seems to point at.
|
2006-03-20 08:21:10 +00:00
|
|
|
head_points_at=$(
|
|
|
|
(
|
2007-01-09 20:26:52 +00:00
|
|
|
test -f "$GIT_DIR/$remote_top/master" && echo "master"
|
2006-03-20 08:21:10 +00:00
|
|
|
cd "$GIT_DIR/$remote_top" &&
|
|
|
|
find . -type f -print | sed -e 's/^\.\///'
|
|
|
|
) | (
|
|
|
|
done=f
|
|
|
|
while read name
|
|
|
|
do
|
|
|
|
test t = $done && continue
|
|
|
|
branch_tip=`cat "$GIT_DIR/$remote_top/$name"`
|
|
|
|
if test "$head_sha1" = "$branch_tip"
|
|
|
|
then
|
|
|
|
echo "$name"
|
|
|
|
done=t
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
)
|
|
|
|
)
|
2006-03-21 08:14:13 +00:00
|
|
|
|
2007-06-16 22:26:08 +00:00
|
|
|
# Upstream URL
|
2007-07-03 05:52:14 +00:00
|
|
|
git config remote."$origin".url "$repo" &&
|
2007-06-16 22:26:08 +00:00
|
|
|
|
|
|
|
# Set up the mappings to track the remote branches.
|
2007-07-03 05:52:14 +00:00
|
|
|
git config remote."$origin".fetch \
|
2007-06-16 22:26:08 +00:00
|
|
|
"+refs/heads/*:$remote_top/*" '^$' &&
|
|
|
|
|
2006-12-16 09:14:39 +00:00
|
|
|
# Write out remote.$origin config, and update our "$head_points_at".
|
2005-11-02 06:19:36 +00:00
|
|
|
case "$head_points_at" in
|
2006-03-20 08:21:10 +00:00
|
|
|
?*)
|
2006-12-16 09:14:39 +00:00
|
|
|
# Local default branch
|
2007-07-03 05:52:14 +00:00
|
|
|
git symbolic-ref HEAD "refs/heads/$head_points_at" &&
|
2006-12-16 09:14:39 +00:00
|
|
|
|
|
|
|
# Tracking branch for the primary branch at the remote.
|
2007-07-03 05:52:14 +00:00
|
|
|
git update-ref HEAD "$head_sha1" &&
|
2006-12-16 09:14:39 +00:00
|
|
|
|
2006-12-16 09:53:10 +00:00
|
|
|
rm -f "refs/remotes/$origin/HEAD"
|
2007-07-03 05:52:14 +00:00
|
|
|
git symbolic-ref "refs/remotes/$origin/HEAD" \
|
2006-12-16 09:53:10 +00:00
|
|
|
"refs/remotes/$origin/$head_points_at" &&
|
2006-12-16 09:14:39 +00:00
|
|
|
|
2007-07-03 05:52:14 +00:00
|
|
|
git config branch."$head_points_at".remote "$origin" &&
|
|
|
|
git config branch."$head_points_at".merge "refs/heads/$head_points_at"
|
2007-06-16 22:26:08 +00:00
|
|
|
;;
|
|
|
|
'')
|
|
|
|
# Source had detached HEAD pointing nowhere
|
2007-07-03 05:52:14 +00:00
|
|
|
git update-ref --no-deref HEAD "$head_sha1" &&
|
2007-06-16 22:26:08 +00:00
|
|
|
rm -f "refs/remotes/$origin/HEAD"
|
|
|
|
;;
|
2005-11-02 06:19:36 +00:00
|
|
|
esac
|
|
|
|
|
2005-09-27 00:17:09 +00:00
|
|
|
case "$no_checkout" in
|
|
|
|
'')
|
2007-02-23 19:03:10 +00:00
|
|
|
test "z$quiet" = z -a "z$no_progress" = z && v=-v || v=
|
2007-07-03 05:52:14 +00:00
|
|
|
git read-tree -m -u $v HEAD HEAD
|
2005-09-27 00:17:09 +00:00
|
|
|
esac
|
|
|
|
fi
|
2006-03-20 08:21:10 +00:00
|
|
|
rm -f "$GIT_DIR/CLONE_HEAD" "$GIT_DIR/REMOTE_HEAD"
|
2006-02-17 21:33:24 +00:00
|
|
|
|
2006-05-22 19:34:00 +00:00
|
|
|
trap - 0
|