git-fetch.shon commit fetch/clone: check return status from ls-remote (57a3969)
   1#!/bin/sh
   2#
   3
   4USAGE='<fetch-options> <repository> <refspec>...'
   5. git-sh-setup
   6. git-parse-remote
   7_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
   8_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
   9
  10LF='
  11'
  12IFS="$LF"
  13
  14rloga=fetch
  15no_tags=
  16tags=
  17append=
  18force=
  19verbose=
  20update_head_ok=
  21exec=
  22upload_pack=
  23while case "$#" in 0) break ;; esac
  24do
  25        case "$1" in
  26        -a|--a|--ap|--app|--appe|--appen|--append)
  27                append=t
  28                ;;
  29        --upl|--uplo|--uploa|--upload|--upload-|--upload-p|\
  30        --upload-pa|--upload-pac|--upload-pack)
  31                shift
  32                exec="--exec=$1" 
  33                upload_pack="-u $1"
  34                ;;
  35        -f|--f|--fo|--for|--forc|--force)
  36                force=t
  37                ;;
  38        -t|--t|--ta|--tag|--tags)
  39                tags=t
  40                ;;
  41        -n|--n|--no|--no-|--no-t|--no-ta|--no-tag|--no-tags)
  42                no_tags=t
  43                ;;
  44        -u|--u|--up|--upd|--upda|--updat|--update|--update-|--update-h|\
  45        --update-he|--update-hea|--update-head|--update-head-|\
  46        --update-head-o|--update-head-ok)
  47                update_head_ok=t
  48                ;;
  49        -v|--verbose)
  50                verbose=Yes
  51                ;;
  52        -k|--k|--ke|--kee|--keep)
  53                keep=--keep
  54                ;;
  55        --reflog-action=*)
  56                rloga=`expr "z$1" : 'z-[^=]*=\(.*\)'`
  57                ;;
  58        -*)
  59                usage
  60                ;;
  61        *)
  62                break
  63                ;;
  64        esac
  65        shift
  66done
  67
  68case "$#" in
  690)
  70        test -f "$GIT_DIR/branches/origin" ||
  71                test -f "$GIT_DIR/remotes/origin" ||
  72                        die "Where do you want to fetch from today?"
  73        set origin ;;
  74esac
  75
  76remote_nick="$1"
  77remote=$(get_remote_url "$@")
  78refs=
  79rref=
  80rsync_slurped_objects=
  81
  82rloga="$rloga $remote_nick"
  83test "$remote_nick" = "$remote" || rloga="$rloga $remote"
  84
  85if test "" = "$append"
  86then
  87        : >"$GIT_DIR/FETCH_HEAD"
  88fi
  89
  90append_fetch_head () {
  91    head_="$1"
  92    remote_="$2"
  93    remote_name_="$3"
  94    remote_nick_="$4"
  95    local_name_="$5"
  96    case "$6" in
  97    t) not_for_merge_='not-for-merge' ;;
  98    '') not_for_merge_= ;;
  99    esac
 100
 101    # remote-nick is the URL given on the command line (or a shorthand)
 102    # remote-name is the $GIT_DIR relative refs/ path we computed
 103    # for this refspec.
 104
 105    # the $note_ variable will be fed to git-fmt-merge-msg for further
 106    # processing.
 107    case "$remote_name_" in
 108    HEAD)
 109        note_= ;;
 110    refs/heads/*)
 111        note_="$(expr "$remote_name_" : 'refs/heads/\(.*\)')"
 112        note_="branch '$note_' of " ;;
 113    refs/tags/*)
 114        note_="$(expr "$remote_name_" : 'refs/tags/\(.*\)')"
 115        note_="tag '$note_' of " ;;
 116    refs/remotes/*)
 117        note_="$(expr "$remote_name_" : 'refs/remotes/\(.*\)')"
 118        note_="remote branch '$note_' of " ;;
 119    *)
 120        note_="$remote_name of " ;;
 121    esac
 122    remote_1_=$(expr "z$remote_" : 'z\(.*\)\.git/*$') &&
 123        remote_="$remote_1_"
 124    note_="$note_$remote_"
 125
 126    # 2.6.11-tree tag would not be happy to be fed to resolve.
 127    if git-cat-file commit "$head_" >/dev/null 2>&1
 128    then
 129        headc_=$(git-rev-parse --verify "$head_^0") || exit
 130        echo "$headc_   $not_for_merge_ $note_" >>"$GIT_DIR/FETCH_HEAD"
 131        [ "$verbose" ] && echo >&2 "* committish: $head_"
 132        [ "$verbose" ] && echo >&2 "  $note_"
 133    else
 134        echo "$head_    not-for-merge   $note_" >>"$GIT_DIR/FETCH_HEAD"
 135        [ "$verbose" ] && echo >&2 "* non-commit: $head_"
 136        [ "$verbose" ] && echo >&2 "  $note_"
 137    fi
 138    if test "$local_name_" != ""
 139    then
 140        # We are storing the head locally.  Make sure that it is
 141        # a fast forward (aka "reverse push").
 142        fast_forward_local "$local_name_" "$head_" "$note_"
 143    fi
 144}
 145
 146fast_forward_local () {
 147    mkdir -p "$(dirname "$GIT_DIR/$1")"
 148    case "$1" in
 149    refs/tags/*)
 150        # Tags need not be pointing at commits so there
 151        # is no way to guarantee "fast-forward" anyway.
 152        if test -f "$GIT_DIR/$1"
 153        then
 154                if now_=$(cat "$GIT_DIR/$1") && test "$now_" = "$2"
 155                then
 156                        [ "$verbose" ] && echo >&2 "* $1: same as $3"
 157                else
 158                        echo >&2 "* $1: updating with $3"
 159                        git-update-ref -m "$rloga: updating tag" "$1" "$2"
 160                fi
 161        else
 162                echo >&2 "* $1: storing $3"
 163                git-update-ref -m "$rloga: storing tag" "$1" "$2"
 164        fi
 165        ;;
 166
 167    refs/heads/* | refs/remotes/*)
 168        # $1 is the ref being updated.
 169        # $2 is the new value for the ref.
 170        local=$(git-rev-parse --verify "$1^0" 2>/dev/null)
 171        if test "$local"
 172        then
 173            # Require fast-forward.
 174            mb=$(git-merge-base "$local" "$2") &&
 175            case "$2,$mb" in
 176            $local,*)
 177                if test -n "$verbose"
 178                then
 179                        echo >&2 "* $1: same as $3"
 180                fi
 181                ;;
 182            *,$local)
 183                echo >&2 "* $1: fast forward to $3"
 184                echo >&2 "  from $local to $2"
 185                git-update-ref -m "$rloga: fast-forward" "$1" "$2" "$local"
 186                ;;
 187            *)
 188                false
 189                ;;
 190            esac || {
 191                echo >&2 "* $1: does not fast forward to $3;"
 192                case ",$force,$single_force," in
 193                *,t,*)
 194                        echo >&2 "  forcing update."
 195                        git-update-ref -m "$rloga: forced-update" "$1" "$2" "$local"
 196                        ;;
 197                *)
 198                        echo >&2 "  not updating."
 199                        exit 1
 200                        ;;
 201                esac
 202            }
 203        else
 204            echo >&2 "* $1: storing $3"
 205            git-update-ref -m "$rloga: storing head" "$1" "$2"
 206        fi
 207        ;;
 208    esac
 209}
 210
 211case "$update_head_ok" in
 212'')
 213        orig_head=$(git-rev-parse --verify HEAD 2>/dev/null)
 214        ;;
 215esac
 216
 217# If --tags (and later --heads or --all) is specified, then we are
 218# not talking about defaults stored in Pull: line of remotes or
 219# branches file, and just fetch those and refspecs explicitly given.
 220# Otherwise we do what we always did.
 221
 222reflist=$(get_remote_refs_for_fetch "$@")
 223if test "$tags"
 224then
 225        taglist=`IFS="  " &&
 226                  (
 227                        git-ls-remote $upload_pack --tags "$remote" ||
 228                        echo fail ouch
 229                  ) |
 230                  while read sha1 name
 231                  do
 232                        case "$sha1" in
 233                        fail)
 234                                exit 1
 235                        esac
 236                        case "$name" in
 237                        *^*) continue ;;
 238                        esac
 239                        if git-check-ref-format "$name"
 240                        then
 241                            echo ".${name}:${name}"
 242                        else
 243                            echo >&2 "warning: tag ${name} ignored"
 244                        fi
 245                  done` || exit
 246        if test "$#" -gt 1
 247        then
 248                # remote URL plus explicit refspecs; we need to merge them.
 249                reflist="$reflist$LF$taglist"
 250        else
 251                # No explicit refspecs; fetch tags only.
 252                reflist=$taglist
 253        fi
 254fi
 255
 256fetch_main () {
 257  reflist="$1"
 258  refs=
 259
 260  for ref in $reflist
 261  do
 262      refs="$refs$LF$ref"
 263
 264      # These are relative path from $GIT_DIR, typically starting at refs/
 265      # but may be HEAD
 266      if expr "z$ref" : 'z\.' >/dev/null
 267      then
 268          not_for_merge=t
 269          ref=$(expr "z$ref" : 'z\.\(.*\)')
 270      else
 271          not_for_merge=
 272      fi
 273      if expr "z$ref" : 'z+' >/dev/null
 274      then
 275          single_force=t
 276          ref=$(expr "z$ref" : 'z+\(.*\)')
 277      else
 278          single_force=
 279      fi
 280      remote_name=$(expr "z$ref" : 'z\([^:]*\):')
 281      local_name=$(expr "z$ref" : 'z[^:]*:\(.*\)')
 282
 283      rref="$rref$LF$remote_name"
 284
 285      # There are transports that can fetch only one head at a time...
 286      case "$remote" in
 287      http://* | https://*)
 288          if [ -n "$GIT_SSL_NO_VERIFY" ]; then
 289              curl_extra_args="-k"
 290          fi
 291          max_depth=5
 292          depth=0
 293          head="ref: $remote_name"
 294          while (expr "z$head" : "zref:" && expr $depth \< $max_depth) >/dev/null
 295          do
 296            remote_name_quoted=$(@@PERL@@ -e '
 297              my $u = $ARGV[0];
 298              $u =~ s/^ref:\s*//;
 299              $u =~ s{([^-a-zA-Z0-9/.])}{sprintf"%%%02x",ord($1)}eg;
 300              print "$u";
 301          ' "$head")
 302            head=$(curl -nsfL $curl_extra_args "$remote/$remote_name_quoted")
 303            depth=$( expr \( $depth + 1 \) )
 304          done
 305          expr "z$head" : "z$_x40\$" >/dev/null ||
 306              die "Failed to fetch $remote_name from $remote"
 307          echo >&2 Fetching "$remote_name from $remote" using http
 308          git-http-fetch -v -a "$head" "$remote/" || exit
 309          ;;
 310      rsync://*)
 311          TMP_HEAD="$GIT_DIR/TMP_HEAD"
 312          rsync -L -q "$remote/$remote_name" "$TMP_HEAD" || exit 1
 313          head=$(git-rev-parse --verify TMP_HEAD)
 314          rm -f "$TMP_HEAD"
 315          test "$rsync_slurped_objects" || {
 316              rsync -av --ignore-existing --exclude info \
 317                  "$remote/objects/" "$GIT_OBJECT_DIRECTORY/" || exit
 318
 319              # Look at objects/info/alternates for rsync -- http will
 320              # support it natively and git native ones will do it on
 321              # the remote end.  Not having that file is not a crime.
 322              rsync -q "$remote/objects/info/alternates" \
 323                  "$GIT_DIR/TMP_ALT" 2>/dev/null ||
 324                  rm -f "$GIT_DIR/TMP_ALT"
 325              if test -f "$GIT_DIR/TMP_ALT"
 326              then
 327                  resolve_alternates "$remote" <"$GIT_DIR/TMP_ALT" |
 328                  while read alt
 329                  do
 330                      case "$alt" in 'bad alternate: '*) die "$alt";; esac
 331                      echo >&2 "Getting alternate: $alt"
 332                      rsync -av --ignore-existing --exclude info \
 333                      "$alt" "$GIT_OBJECT_DIRECTORY/" || exit
 334                  done
 335                  rm -f "$GIT_DIR/TMP_ALT"
 336              fi
 337              rsync_slurped_objects=t
 338          }
 339          ;;
 340      *)
 341          # We will do git native transport with just one call later.
 342          continue ;;
 343      esac
 344
 345      append_fetch_head "$head" "$remote" \
 346          "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
 347
 348  done
 349
 350  case "$remote" in
 351  http://* | https://* | rsync://* )
 352      ;; # we are already done.
 353  *)
 354    ( : subshell because we muck with IFS
 355      IFS="     $LF"
 356      (
 357          git-fetch-pack $exec $keep --thin "$remote" $rref || echo failed "$remote"
 358      ) |
 359      while read sha1 remote_name
 360      do
 361          case "$sha1" in
 362          failed)
 363                  echo >&2 "Fetch failure: $remote"
 364                  exit 1 ;;
 365          esac
 366          found=
 367          single_force=
 368          for ref in $refs
 369          do
 370              case "$ref" in
 371              +$remote_name:*)
 372                  single_force=t
 373                  not_for_merge=
 374                  found="$ref"
 375                  break ;;
 376              .+$remote_name:*)
 377                  single_force=t
 378                  not_for_merge=t
 379                  found="$ref"
 380                  break ;;
 381              .$remote_name:*)
 382                  not_for_merge=t
 383                  found="$ref"
 384                  break ;;
 385              $remote_name:*)
 386                  not_for_merge=
 387                  found="$ref"
 388                  break ;;
 389              esac
 390          done
 391          local_name=$(expr "z$found" : 'z[^:]*:\(.*\)')
 392          append_fetch_head "$sha1" "$remote" \
 393                  "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
 394      done
 395    ) || exit ;;
 396  esac
 397
 398}
 399
 400fetch_main "$reflist"
 401
 402# automated tag following
 403case "$no_tags$tags" in
 404'')
 405        case "$reflist" in
 406        *:refs/*)
 407                # effective only when we are following remote branch
 408                # using local tracking branch.
 409                taglist=$(IFS=" " &&
 410                git-ls-remote $upload_pack --tags "$remote" |
 411                sed -ne 's|^\([0-9a-f]*\)[      ]\(refs/tags/.*\)^{}$|\1 \2|p' |
 412                while read sha1 name
 413                do
 414                        test -f "$GIT_DIR/$name" && continue
 415                        git-check-ref-format "$name" || {
 416                                echo >&2 "warning: tag ${name} ignored"
 417                                continue
 418                        }
 419                        git-cat-file -t "$sha1" >/dev/null 2>&1 || continue
 420                        echo >&2 "Auto-following $name"
 421                        echo ".${name}:${name}"
 422                done)
 423        esac
 424        case "$taglist" in
 425        '') ;;
 426        ?*)
 427                fetch_main "$taglist" ;;
 428        esac
 429esac
 430
 431# If the original head was empty (i.e. no "master" yet), or
 432# if we were told not to worry, we do not have to check.
 433case ",$update_head_ok,$orig_head," in
 434*,, | t,* )
 435        ;;
 436*)
 437        curr_head=$(git-rev-parse --verify HEAD 2>/dev/null)
 438        if test "$curr_head" != "$orig_head"
 439        then
 440            git-update-ref \
 441                        -m "$rloga: Undoing incorrectly fetched HEAD." \
 442                        HEAD "$orig_head"
 443                die "Cannot fetch into the current branch."
 444        fi
 445        ;;
 446esac