git-am: interactive should fail gracefully.
[git] / git-fetch.sh
1 #!/bin/sh
2 #
3 . git-sh-setup || die "Not a git archive"
4 . git-parse-remote
5 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
6 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
7
8 LF='
9 '
10 IFS="$LF"
11
12 tags=
13 append=
14 force=
15 update_head_ok=
16 while case "$#" in 0) break ;; esac
17 do
18         case "$1" in
19         -a|--a|--ap|--app|--appe|--appen|--append)
20                 append=t
21                 ;;
22         -f|--f|--fo|--for|--forc|--force)
23                 force=t
24                 ;;
25         -t|--t|--ta|--tag|--tags)
26                 tags=t
27                 ;;
28         -u|--u|--up|--upd|--upda|--updat|--update|--update-|--update-h|\
29         --update-he|--update-hea|--update-head|--update-head-|\
30         --update-head-o|--update-head-ok)
31                 update_head_ok=t
32                 ;;
33         *)
34                 break
35                 ;;
36         esac
37         shift
38 done
39
40 case "$#" in
41 0)
42         test -f "$GIT_DIR/branches/origin" ||
43                 test -f "$GIT_DIR/remotes/origin" ||
44                         die "Where do you want to fetch from today?"
45         set origin ;;
46 esac
47
48 remote_nick="$1"
49 remote=$(get_remote_url "$@")
50 refs=
51 rref=
52 rsync_slurped_objects=
53
54 if test "" = "$append"
55 then
56         : >"$GIT_DIR/FETCH_HEAD"
57 fi
58
59 append_fetch_head () {
60     head_="$1"
61     remote_="$2"
62     remote_name_="$3"
63     remote_nick_="$4"
64     local_name_="$5"
65     case "$6" in
66     t) not_for_merge_='not-for-merge' ;;
67     '') not_for_merge_= ;;
68     esac
69
70     # remote-nick is the URL given on the command line (or a shorthand)
71     # remote-name is the $GIT_DIR relative refs/ path we computed
72     # for this refspec.
73     case "$remote_name_" in
74     HEAD)
75         note_= ;;
76     refs/heads/*)
77         note_="$(expr "$remote_name_" : 'refs/heads/\(.*\)')"
78         note_="branch '$note_' of " ;;
79     refs/tags/*)
80         note_="$(expr "$remote_name_" : 'refs/tags/\(.*\)')"
81         note_="tag '$note_' of " ;;
82     *)
83         note_="$remote_name of " ;;
84     esac
85     remote_1_=$(expr "$remote_" : '\(.*\)\.git/*$') &&
86         remote_="$remote_1_"
87     note_="$note_$remote_"
88
89     # 2.6.11-tree tag would not be happy to be fed to resolve.
90     if git-cat-file commit "$head_" >/dev/null 2>&1
91     then
92         headc_=$(git-rev-parse --verify "$head_^0") || exit
93         echo "$headc_   $not_for_merge_ $note_" >>"$GIT_DIR/FETCH_HEAD"
94         echo >&2 "* committish: $head_"
95         echo >&2 "  $note_"
96     else
97         echo "$head_    not-for-merge   $note_" >>"$GIT_DIR/FETCH_HEAD"
98         echo >&2 "* non-commit: $head_"
99         echo >&2 "  $note_"
100     fi
101     if test "$local_name_" != ""
102     then
103         # We are storing the head locally.  Make sure that it is
104         # a fast forward (aka "reverse push").
105         fast_forward_local "$local_name_" "$head_" "$note_"
106     fi
107 }
108
109 fast_forward_local () {
110     mkdir -p "$(dirname "$GIT_DIR/$1")"
111     case "$1" in
112     refs/tags/*)
113         # Tags need not be pointing at commits so there
114         # is no way to guarantee "fast-forward" anyway.
115         if test -f "$GIT_DIR/$1"
116         then
117                 echo >&2 "* $1: updating with $3"
118         else
119                 echo >&2 "* $1: storing $3"
120         fi
121         git-update-ref "$1" "$2" 
122         ;;
123
124     refs/heads/*)
125         # $1 is the ref being updated.
126         # $2 is the new value for the ref.
127         local=$(git-rev-parse --verify "$1^0" 2>/dev/null)
128         if test "$local"
129         then
130             # Require fast-forward.
131             mb=$(git-merge-base "$local" "$2") &&
132             case "$2,$mb" in
133             $local,*)
134                 echo >&2 "* $1: same as $3"
135                 ;;
136             *,$local)
137                 echo >&2 "* $1: fast forward to $3"
138                 git-update-ref "$1" "$2" "$local"
139                 ;;
140             *)
141                 false
142                 ;;
143             esac || {
144                 echo >&2 "* $1: does not fast forward to $3;"
145                 case ",$force,$single_force," in
146                 *,t,*)
147                         echo >&2 "  forcing update."
148                         git-update-ref "$1" "$2" "$local"
149                         ;;
150                 *)
151                         echo >&2 "  not updating."
152                         ;;
153                 esac
154             }
155         else
156             echo >&2 "* $1: storing $3"
157             git-update-ref "$1" "$2"
158         fi
159         ;;
160     esac
161 }
162
163 case "$update_head_ok" in
164 '')
165         orig_head=$(git-rev-parse --verify HEAD 2>/dev/null)
166         ;;
167 esac
168
169 # If --tags (and later --heads or --all) is specified, then we are
170 # not talking about defaults stored in Pull: line of remotes or
171 # branches file, and just fetch those and refspecs explicitly given.
172 # Otherwise we do what we always did.
173
174 reflist=$(get_remote_refs_for_fetch "$@")
175 if test "$tags"
176 then
177         taglist=$(git-ls-remote --tags "$remote" |
178                 sed -e '
179                         s/^[^   ]*      //
180                         s/.*/&:&/')
181         if test "$#" -gt 1
182         then
183                 # remote URL plus explicit refspecs; we need to merge them.
184                 reflist="$reflist$LF$taglist"
185         else
186                 # No explicit refspecs; fetch tags only.
187                 reflist=$taglist
188         fi
189 fi
190
191 for ref in $reflist
192 do
193     refs="$refs$LF$ref"
194
195     # These are relative path from $GIT_DIR, typically starting at refs/
196     # but may be HEAD
197     if expr "$ref" : '\.' >/dev/null
198     then
199         not_for_merge=t
200         ref=$(expr "$ref" : '\.\(.*\)')
201     else
202         not_for_merge=
203     fi
204     if expr "$ref" : '\+' >/dev/null
205     then
206         single_force=t
207         ref=$(expr "$ref" : '\+\(.*\)')
208     else
209         single_force=
210     fi
211     remote_name=$(expr "$ref" : '\([^:]*\):')
212     local_name=$(expr "$ref" : '[^:]*:\(.*\)')
213
214     rref="$rref$LF$remote_name"
215
216     # There are transports that can fetch only one head at a time...
217     case "$remote" in
218     http://* | https://*)
219         if [ -n "$GIT_SSL_NO_VERIFY" ]; then
220             curl_extra_args="-k"
221         fi
222         remote_name_quoted=$(perl -e '
223             my $u = $ARGV[0];
224             $u =~ s{([^-a-zA-Z0-9/.])}{sprintf"%%%02x",ord($1)}eg;
225             print "$u";
226         ' "$remote_name")
227         head=$(curl -nsf $curl_extra_args "$remote/$remote_name_quoted") &&
228         expr "$head" : "$_x40\$" >/dev/null ||
229                 die "Failed to fetch $remote_name from $remote"
230         echo >&2 Fetching "$remote_name from $remote" using http
231         git-http-fetch -v -a "$head" "$remote/" || exit
232         ;;
233     rsync://*)
234         TMP_HEAD="$GIT_DIR/TMP_HEAD"
235         rsync -L -q "$remote/$remote_name" "$TMP_HEAD" || exit 1
236         head=$(git-rev-parse --verify TMP_HEAD)
237         rm -f "$TMP_HEAD"
238         test "$rsync_slurped_objects" || {
239             rsync -av --ignore-existing --exclude info \
240                 "$remote/objects/" "$GIT_OBJECT_DIRECTORY/" || exit
241
242             # Look at objects/info/alternates for rsync -- http will
243             # support it natively and git native ones will do it on the remote
244             # end.  Not having that file is not a crime.
245             rsync -q "$remote/objects/info/alternates" \
246                 "$GIT_DIR/TMP_ALT" 2>/dev/null ||
247                 rm -f "$GIT_DIR/TMP_ALT"
248             if test -f "$GIT_DIR/TMP_ALT"
249             then
250                 resolve_alternates "$remote" <"$GIT_DIR/TMP_ALT" |
251                 while read alt
252                 do
253                     case "$alt" in 'bad alternate: '*) die "$alt";; esac
254                     echo >&2 "Getting alternate: $alt"
255                     rsync -av --ignore-existing --exclude info \
256                     "$alt" "$GIT_OBJECT_DIRECTORY/" || exit
257                 done
258                 rm -f "$GIT_DIR/TMP_ALT"
259             fi
260             rsync_slurped_objects=t
261         }
262         ;;
263     *)
264         # We will do git native transport with just one call later.
265         continue ;;
266     esac
267
268     append_fetch_head "$head" "$remote" \
269         "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
270
271 done
272
273 case "$remote" in
274 http://* | https://* | rsync://* )
275     ;; # we are already done.
276 *)
277     IFS="       $LF"
278     (
279         git-fetch-pack "$remote" $rref || echo failed "$remote"
280     ) |
281     while read sha1 remote_name
282     do
283         case "$sha1" in
284         failed)
285                 echo >&2 "Fetch failure: $remote"
286                 exit 1 ;;
287         esac
288         found=
289         single_force=
290         for ref in $refs
291         do
292             case "$ref" in
293             +$remote_name:*)
294                 single_force=t
295                 not_for_merge=
296                 found="$ref"
297                 break ;;
298             .+$remote_name:*)
299                 single_force=t
300                 not_for_merge=t
301                 found="$ref"
302                 break ;;
303             .$remote_name:*)
304                 not_for_merge=t
305                 found="$ref"
306                 break ;;
307             $remote_name:*)
308                 not_for_merge=
309                 found="$ref"
310                 break ;;
311             esac
312         done
313         local_name=$(expr "$found" : '[^:]*:\(.*\)')
314         append_fetch_head "$sha1" "$remote" \
315                 "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
316     done || exit
317     ;;
318 esac
319
320 # If the original head was empty (i.e. no "master" yet), or
321 # if we were told not to worry, we do not have to check.
322 case ",$update_head_ok,$orig_head," in
323 *,, | t,* )
324         ;;
325 *)
326         curr_head=$(git-rev-parse --verify HEAD 2>/dev/null)
327         if test "$curr_head" != "$orig_head"
328         then
329                 git-update-ref HEAD "$orig_head"
330                 die "Cannot fetch into the current branch."
331         fi
332         ;;
333 esac