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