[thirdparty/git.git] / git-clone.sh

#!/bin/sh
#
# Copyright (c) 2005, Linus Torvalds
# Copyright (c) 2005, Junio C Hamano
# 
# Clone a repository into a different directory that does not yet exist.

# See git-sh-setup why.
unset CDPATH

usage() {
	echo >&2 "Usage: $0 [--bare] [-l [-s]] [-q] [-u <upload-pack>] [-o <name>] [-n] <repo> [<dir>]"
	exit 1
}

get_repo_base() {
	(cd "$1" && (cd .git ; pwd)) 2> /dev/null
}

if [ -n "$GIT_SSL_NO_VERIFY" ]; then
    curl_extra_args="-k"
fi

http_fetch () {
	# $1 = Remote, $2 = Local
	curl -nsfL $curl_extra_args "$1" >"$2"
}

clone_dumb_http () {
	# $1 - remote, $2 - local
	cd "$2" &&
	clone_tmp='.git/clone-tmp' &&
	mkdir -p "$clone_tmp" || exit 1
	http_fetch "$1/info/refs" "$clone_tmp/refs" || {
		echo >&2 "Cannot get remote repository information.
Perhaps git-update-server-info needs to be run there?"
		exit 1;
	}
	while read sha1 refname
	do
		name=`expr "$refname" : 'refs/\(.*\)'` &&
		case "$name" in
		*^*)	;;
		*)
			git-http-fetch -v -a -w "$name" "$name" "$1/" || exit 1
		esac
	done <"$clone_tmp/refs"
	rm -fr "$clone_tmp"
}

quiet=
use_local=no
local_shared=no
no_checkout=
upload_pack=
bare=
origin=origin
origin_override=
while
	case "$#,$1" in
	0,*) break ;;
	*,-n|*,--no|*,--no-|*,--no-c|*,--no-ch|*,--no-che|*,--no-chec|\
	*,--no-check|*,--no-checko|*,--no-checkou|*,--no-checkout)
	  no_checkout=yes ;;
	*,--na|*,--nak|*,--nake|*,--naked|\
	*,-b|*,--b|*,--ba|*,--bar|*,--bare) bare=yes ;;
	*,-l|*,--l|*,--lo|*,--loc|*,--loca|*,--local) use_local=yes ;;
        *,-s|*,--s|*,--sh|*,--sha|*,--shar|*,--share|*,--shared) 
          local_shared=yes; use_local=yes ;;
	*,-q|*,--quiet) quiet=-q ;;
	1,-o) usage;;
	*,-o)
		git-check-ref-format "$2" || {
		    echo >&2 "'$2' is not suitable for a branch name"
		    exit 1
		}
		test -z "$origin_override" || {
		    echo >&2 "Do not give more than one -o options."
		    exit 1
		}
		origin_override=yes
		origin="$2"; shift
		;;
	1,-u|1,--upload-pack) usage ;;
	*,-u|*,--upload-pack)
		shift
		upload_pack="--exec=$1" ;;
	*,-*) usage ;;
	*) break ;;
	esac
do
	shift
done

# --bare implies --no-checkout
if test yes = "$bare"
then
	if test yes = "$origin_override"
	then
		echo >&2 '--bare and -o $origin options are incompatible.'
		exit 1
	fi
	no_checkout=yes
fi

# Turn the source into an absolute path if
# it is local
repo="$1"
local=no
if base=$(get_repo_base "$repo"); then
	repo="$base"
	local=yes
fi

dir="$2"
# Try using "humanish" part of source repo if user didn't specify one
[ -z "$dir" ] && dir=$(echo "$repo" | sed -e 's|/$||' -e 's|:*/*\.git$||' -e 's|.*[/:]||g')
[ -e "$dir" ] && echo "$dir already exists." && usage
mkdir -p "$dir" &&
D=$(cd "$dir" && pwd) &&
trap 'err=$?; cd ..; rm -r "$D"; exit $err' exit
case "$bare" in
yes) GIT_DIR="$D" ;;
*) GIT_DIR="$D/.git" ;;
esac && export GIT_DIR && git-init-db || usage
case "$bare" in
yes)
	GIT_DIR="$D" ;;
*)
	GIT_DIR="$D/.git" ;;
esac

# We do local magic only when the user tells us to.
case "$local,$use_local" in
yes,yes)
	( cd "$repo/objects" ) || {
		echo >&2 "-l flag seen but $repo is not local."
		exit 1
	}

	case "$local_shared" in
	no)
	    # 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 since we are cloning!
	    test -f "$repo/$sample_file" || exit

	    l=
	    if ln "$repo/$sample_file" "$GIT_DIR/objects/sample" 2>/dev/null
	    then
		    l=l
	    fi &&
	    rm -f "$GIT_DIR/objects/sample" &&
	    cd "$repo" &&
	    find objects -depth -print | cpio -pumd$l "$GIT_DIR/" || exit 1
	    ;;
	yes)
	    mkdir -p "$GIT_DIR/objects/info"
	    {
		test -f "$repo/objects/info/alternates" &&
		cat "$repo/objects/info/alternates";
		echo "$repo/objects"
	    } >"$GIT_DIR/objects/info/alternates"
	    ;;
	esac

	# Make a duplicate of refs and HEAD pointer
	HEAD=
	if test -f "$repo/HEAD"
	then
		HEAD=HEAD
	fi
	(cd "$repo" && tar cf - refs $HEAD) |
	(cd "$GIT_DIR" && tar xf -) || exit 1
	;;
*)
	case "$repo" in
	rsync://*)
		rsync $quiet -av --ignore-existing  \
			--exclude info "$repo/objects/" "$GIT_DIR/objects/" &&
		rsync $quiet -av --ignore-existing  \
			--exclude info "$repo/refs/" "$GIT_DIR/refs/" || exit

		# 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.
		rsync -q "$repo/objects/info/alternates" \
			"$GIT_DIR/TMP_ALT" 2>/dev/null ||
			rm -f "$GIT_DIR/TMP_ALT"
		if test -f "$GIT_DIR/TMP_ALT"
		then
		    ( cd "$D" &&
		      . git-parse-remote &&
		      resolve_alternates "$repo" <"$GIT_DIR/TMP_ALT" ) |
		    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  \
			    --exclude info "$alt" "$GIT_DIR/objects" || exit
		    done
		    rm -f "$GIT_DIR/TMP_ALT"
		fi
		;;
	http://*)
		if test -z "@@NO_CURL@@"
		then
			clone_dumb_http "$repo" "$D"
		else
			echo >&2 "http transport not supported, rebuild Git with curl support"
			exit 1
		fi
		;;
	*)
		cd "$D" && case "$upload_pack" in
		'') git-clone-pack $quiet "$repo" ;;
		*) git-clone-pack $quiet "$upload_pack" "$repo" ;;
		esac || {
			echo >&2 "clone-pack from '$repo' failed."
			exit 1
		}
		;;
	esac
	;;
esac

cd "$D" || exit

if test -f "$GIT_DIR/HEAD" && test -z "$bare"
then
	head_points_at=`git-symbolic-ref HEAD`
	case "$head_points_at" in
	refs/heads/*)
		head_points_at=`expr "$head_points_at" : 'refs/heads/\(.*\)'`
		mkdir -p "$GIT_DIR/remotes" &&
		echo >"$GIT_DIR/remotes/origin" \
		"URL: $repo
Pull: $head_points_at:$origin" &&
		git-update-ref "refs/heads/$origin" $(git-rev-parse HEAD) &&
		(cd "$GIT_DIR" && find "refs/heads" -type f -print) |
		while read ref
		do
			head=`expr "$ref" : 'refs/heads/\(.*\)'` &&
			test "$head_points_at" = "$head" ||
			test "$origin" = "$head" ||
			echo "Pull: ${head}:${head}"
		done >>"$GIT_DIR/remotes/origin"
	esac

	case "$no_checkout" in
	'')
		git-read-tree -m -u -v HEAD HEAD
	esac
fi

trap - exit
Commit	Line	Data
	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2005, Linus Torvalds
	4	# Copyright (c) 2005, Junio C Hamano
	5	#
	6	# Clone a repository into a different directory that does not yet exist.
	7
	8	# See git-sh-setup why.
	9	unset CDPATH
	10
	11	usage() {
	12	echo >&2 "Usage: $0 [--bare] [-l [-s]] [-q] [-u <upload-pack>] [-o <name>] [-n] <repo> [<dir>]"
	13	exit 1
	14	}
	15
	16	get_repo_base() {
	17	(cd "$1" && (cd .git ; pwd)) 2> /dev/null
	18	}
	19
	20	if [ -n "$GIT_SSL_NO_VERIFY" ]; then
	21	curl_extra_args="-k"
	22	fi
	23
	24	http_fetch () {
	25	# $1 = Remote, $2 = Local
	26	curl -nsfL $curl_extra_args "$1" >"$2"
	27	}
	28
	29	clone_dumb_http () {
	30	# $1 - remote, $2 - local
	31	cd "$2" &&
	32	clone_tmp='.git/clone-tmp' &&
	33	mkdir -p "$clone_tmp" \|\| exit 1
	34	http_fetch "$1/info/refs" "$clone_tmp/refs" \|\| {
	35	echo >&2 "Cannot get remote repository information.
	36	Perhaps git-update-server-info needs to be run there?"
	37	exit 1;
	38	}
	39	while read sha1 refname
	40	do
	41	name=`expr "$refname" : 'refs/\(.*\)'` &&
	42	case "$name" in
	43	^) ;;
	44	*)
	45	git-http-fetch -v -a -w "$name" "$name" "$1/" \|\| exit 1
	46	esac
	47	done <"$clone_tmp/refs"
	48	rm -fr "$clone_tmp"
	49	}
	50
	51	quiet=
	52	use_local=no
	53	local_shared=no
	54	no_checkout=
	55	upload_pack=
	56	bare=
	57	origin=origin
	58	origin_override=
	59	while
	60	case "$#,$1" in
	61	0,*) break ;;
	62	,-n\|,--no\|,--no-\|,--no-c\|,--no-ch\|,--no-che\|*,--no-chec\|\
	63	,--no-check\|,--no-checko\|,--no-checkou\|,--no-checkout)
	64	no_checkout=yes ;;
	65	,--na\|,--nak\|,--nake\|,--naked\|\
	66	,-b\|,--b\|,--ba\|,--bar\|*,--bare) bare=yes ;;
	67	,-l\|,--l\|,--lo\|,--loc\|,--loca\|,--local) use_local=yes ;;
	68	,-s\|,--s\|,--sh\|,--sha\|,--shar\|,--share\|*,--shared)
	69	local_shared=yes; use_local=yes ;;
	70	,-q\|,--quiet) quiet=-q ;;
	71	1,-o) usage;;
	72	*,-o)
	73	git-check-ref-format "$2" \|\| {
	74	echo >&2 "'$2' is not suitable for a branch name"
	75	exit 1
	76	}
	77	test -z "$origin_override" \|\| {
	78	echo >&2 "Do not give more than one -o options."
	79	exit 1
	80	}
	81	origin_override=yes
	82	origin="$2"; shift
	83	;;
	84	1,-u\|1,--upload-pack) usage ;;
	85	,-u\|,--upload-pack)
	86	shift
	87	upload_pack="--exec=$1" ;;
	88	,-) usage ;;
	89	*) break ;;
	90	esac
	91	do
	92	shift
	93	done
	94
	95	# --bare implies --no-checkout
	96	if test yes = "$bare"
	97	then
	98	if test yes = "$origin_override"
	99	then
	100	echo >&2 '--bare and -o $origin options are incompatible.'
	101	exit 1
	102	fi
	103	no_checkout=yes
	104	fi
	105
	106	# Turn the source into an absolute path if
	107	# it is local
	108	repo="$1"
	109	local=no
	110	if base=$(get_repo_base "$repo"); then
	111	repo="$base"
	112	local=yes
	113	fi
	114
	115	dir="$2"
	116	# Try using "humanish" part of source repo if user didn't specify one
	117	[ -z "$dir" ] && dir=$(echo "$repo" \| sed -e 's\|/$\|\|' -e 's\|:/\.git$\|\|' -e 's\|.*[/:]\|\|g')
	118	[ -e "$dir" ] && echo "$dir already exists." && usage
	119	mkdir -p "$dir" &&
	120	D=$(cd "$dir" && pwd) &&
	121	trap 'err=$?; cd ..; rm -r "$D"; exit $err' exit
	122	case "$bare" in
	123	yes) GIT_DIR="$D" ;;
	124	*) GIT_DIR="$D/.git" ;;
	125	esac && export GIT_DIR && git-init-db \|\| usage
	126	case "$bare" in
	127	yes)
	128	GIT_DIR="$D" ;;
	129	*)
	130	GIT_DIR="$D/.git" ;;
	131	esac
	132
	133	# We do local magic only when the user tells us to.
	134	case "$local,$use_local" in
	135	yes,yes)
	136	( cd "$repo/objects" ) \|\| {
	137	echo >&2 "-l flag seen but $repo is not local."
	138	exit 1
	139	}
	140
	141	case "$local_shared" in
	142	no)
	143	# See if we can hardlink and drop "l" if not.
	144	sample_file=$(cd "$repo" && \
	145	find objects -type f -print \| sed -e 1q)
	146
	147	# objects directory should not be empty since we are cloning!
	148	test -f "$repo/$sample_file" \|\| exit
	149
	150	l=
	151	if ln "$repo/$sample_file" "$GIT_DIR/objects/sample" 2>/dev/null
	152	then
	153	l=l
	154	fi &&
	155	rm -f "$GIT_DIR/objects/sample" &&
	156	cd "$repo" &&
	157	find objects -depth -print \| cpio -pumd$l "$GIT_DIR/" \|\| exit 1
	158	;;
	159	yes)
	160	mkdir -p "$GIT_DIR/objects/info"
	161	{
	162	test -f "$repo/objects/info/alternates" &&
	163	cat "$repo/objects/info/alternates";
	164	echo "$repo/objects"
	165	} >"$GIT_DIR/objects/info/alternates"
	166	;;
	167	esac
	168
	169	# Make a duplicate of refs and HEAD pointer
	170	HEAD=
	171	if test -f "$repo/HEAD"
	172	then
	173	HEAD=HEAD
	174	fi
	175	(cd "$repo" && tar cf - refs $HEAD) \|
	176	(cd "$GIT_DIR" && tar xf -) \|\| exit 1
	177	;;
	178	*)
	179	case "$repo" in
	180	rsync://*)
	181	rsync $quiet -av --ignore-existing \
	182	--exclude info "$repo/objects/" "$GIT_DIR/objects/" &&
	183	rsync $quiet -av --ignore-existing \
	184	--exclude info "$repo/refs/" "$GIT_DIR/refs/" \|\| exit
	185
	186	# Look at objects/info/alternates for rsync -- http will
	187	# support it natively and git native ones will do it on the
	188	# remote end. Not having that file is not a crime.
	189	rsync -q "$repo/objects/info/alternates" \
	190	"$GIT_DIR/TMP_ALT" 2>/dev/null \|\|
	191	rm -f "$GIT_DIR/TMP_ALT"
	192	if test -f "$GIT_DIR/TMP_ALT"
	193	then
	194	( cd "$D" &&
	195	. git-parse-remote &&
	196	resolve_alternates "$repo" <"$GIT_DIR/TMP_ALT" ) \|
	197	while read alt
	198	do
	199	case "$alt" in 'bad alternate: '*) die "$alt";; esac
	200	case "$quiet" in
	201	'') echo >&2 "Getting alternate: $alt" ;;
	202	esac
	203	rsync $quiet -av --ignore-existing \
	204	--exclude info "$alt" "$GIT_DIR/objects" \|\| exit
	205	done
	206	rm -f "$GIT_DIR/TMP_ALT"
	207	fi
	208	;;
	209	http://*)
	210	if test -z "@@NO_CURL@@"
	211	then
	212	clone_dumb_http "$repo" "$D"
	213	else
	214	echo >&2 "http transport not supported, rebuild Git with curl support"
	215	exit 1
	216	fi
	217	;;
	218	*)
	219	cd "$D" && case "$upload_pack" in
	220	'') git-clone-pack $quiet "$repo" ;;
	221	*) git-clone-pack $quiet "$upload_pack" "$repo" ;;
	222	esac \|\| {
	223	echo >&2 "clone-pack from '$repo' failed."
	224	exit 1
	225	}
	226	;;
	227	esac
	228	;;
	229	esac
	230
	231	cd "$D" \|\| exit
	232
	233	if test -f "$GIT_DIR/HEAD" && test -z "$bare"
	234	then
	235	head_points_at=`git-symbolic-ref HEAD`
	236	case "$head_points_at" in
	237	refs/heads/*)
	238	head_points_at=`expr "$head_points_at" : 'refs/heads/\(.*\)'`
	239	mkdir -p "$GIT_DIR/remotes" &&
	240	echo >"$GIT_DIR/remotes/origin" \
	241	"URL: $repo
	242	Pull: $head_points_at:$origin" &&
	243	git-update-ref "refs/heads/$origin" $(git-rev-parse HEAD) &&
	244	(cd "$GIT_DIR" && find "refs/heads" -type f -print) \|
	245	while read ref
	246	do
	247	head=`expr "$ref" : 'refs/heads/\(.*\)'` &&
	248	test "$head_points_at" = "$head" \|\|
	249	test "$origin" = "$head" \|\|
	250	echo "Pull: ${head}:${head}"
	251	done >>"$GIT_DIR/remotes/origin"
	252	esac
	253
	254	case "$no_checkout" in
	255	'')
	256	git-read-tree -m -u -v HEAD HEAD
	257	esac
	258	fi
	259
	260	trap - exit
	261