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