Andrew's git / gitweb.git / git-fetch.sh
?
git-fetch.shon commit Add support for pushing to a remote repository using HTTP/DAV (58e60dd)
   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
   8LF='
   9'
  10IFS="$LF"
  11
  12tags=
  13append=
  14force=
  15update_head_ok=
  16while case "$#" in 0) break ;; esac
  17do
  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
  38done
  39
  40case "$#" in
  410)
  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 ;;
  46esac
  47
  48remote_nick="$1"
  49remote=$(get_remote_url "$@")
  50refs=
  51rref=
  52rsync_slurped_objects=
  53
  54if test "" = "$append"
  55then
  56        : >"$GIT_DIR/FETCH_HEAD"
  57fi
  58
  59append_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
 109fast_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                if now_=$(cat "$GIT_DIR/$1") && test "$now_" = "$2"
 118                then
 119                        echo >&2 "* $1: same as $3"
 120                else
 121                        echo >&2 "* $1: updating with $3"
 122                fi
 123        else
 124                echo >&2 "* $1: storing $3"
 125        fi
 126        git-update-ref "$1" "$2" 
 127        ;;
 128
 129    refs/heads/*)
 130        # $1 is the ref being updated.
 131        # $2 is the new value for the ref.
 132        local=$(git-rev-parse --verify "$1^0" 2>/dev/null)
 133        if test "$local"
 134        then
 135            # Require fast-forward.
 136            mb=$(git-merge-base "$local" "$2") &&
 137            case "$2,$mb" in
 138            $local,*)
 139                echo >&2 "* $1: same as $3"
 140                ;;
 141            *,$local)
 142                echo >&2 "* $1: fast forward to $3"
 143                git-update-ref "$1" "$2" "$local"
 144                ;;
 145            *)
 146                false
 147                ;;
 148            esac || {
 149                echo >&2 "* $1: does not fast forward to $3;"
 150                case ",$force,$single_force," in
 151                *,t,*)
 152                        echo >&2 "  forcing update."
 153                        git-update-ref "$1" "$2" "$local"
 154                        ;;
 155                *)
 156                        echo >&2 "  not updating."
 157                        ;;
 158                esac
 159            }
 160        else
 161            echo >&2 "* $1: storing $3"
 162            git-update-ref "$1" "$2"
 163        fi
 164        ;;
 165    esac
 166}
 167
 168case "$update_head_ok" in
 169'')
 170        orig_head=$(git-rev-parse --verify HEAD 2>/dev/null)
 171        ;;
 172esac
 173
 174# If --tags (and later --heads or --all) is specified, then we are
 175# not talking about defaults stored in Pull: line of remotes or
 176# branches file, and just fetch those and refspecs explicitly given.
 177# Otherwise we do what we always did.
 178
 179reflist=$(get_remote_refs_for_fetch "$@")
 180if test "$tags"
 181then
 182        taglist=$(git-ls-remote --tags "$remote" |
 183                sed -e '
 184                        /\^/d
 185                        s/^[^   ]*      //
 186                        s/.*/&:&/')
 187        if test "$#" -gt 1
 188        then
 189                # remote URL plus explicit refspecs; we need to merge them.
 190                reflist="$reflist$LF$taglist"
 191        else
 192                # No explicit refspecs; fetch tags only.
 193                reflist=$taglist
 194        fi
 195fi
 196
 197for ref in $reflist
 198do
 199    refs="$refs$LF$ref"
 200
 201    # These are relative path from $GIT_DIR, typically starting at refs/
 202    # but may be HEAD
 203    if expr "$ref" : '\.' >/dev/null
 204    then
 205        not_for_merge=t
 206        ref=$(expr "$ref" : '\.\(.*\)')
 207    else
 208        not_for_merge=
 209    fi
 210    if expr "$ref" : '\+' >/dev/null
 211    then
 212        single_force=t
 213        ref=$(expr "$ref" : '\+\(.*\)')
 214    else
 215        single_force=
 216    fi
 217    remote_name=$(expr "$ref" : '\([^:]*\):')
 218    local_name=$(expr "$ref" : '[^:]*:\(.*\)')
 219
 220    rref="$rref$LF$remote_name"
 221
 222    # There are transports that can fetch only one head at a time...
 223    case "$remote" in
 224    http://* | https://*)
 225        if [ -n "$GIT_SSL_NO_VERIFY" ]; then
 226            curl_extra_args="-k"
 227        fi
 228        remote_name_quoted=$(perl -e '
 229            my $u = $ARGV[0];
 230            $u =~ s{([^-a-zA-Z0-9/.])}{sprintf"%%%02x",ord($1)}eg;
 231            print "$u";
 232        ' "$remote_name")
 233        head=$(curl -nsf $curl_extra_args "$remote/$remote_name_quoted") &&
 234        expr "$head" : "$_x40\$" >/dev/null ||
 235                die "Failed to fetch $remote_name from $remote"
 236        echo >&2 Fetching "$remote_name from $remote" using http
 237        git-http-fetch -v -a "$head" "$remote/" || exit
 238        ;;
 239    rsync://*)
 240        TMP_HEAD="$GIT_DIR/TMP_HEAD"
 241        rsync -L -q "$remote/$remote_name" "$TMP_HEAD" || exit 1
 242        head=$(git-rev-parse --verify TMP_HEAD)
 243        rm -f "$TMP_HEAD"
 244        test "$rsync_slurped_objects" || {
 245            rsync -av --ignore-existing --exclude info \
 246                "$remote/objects/" "$GIT_OBJECT_DIRECTORY/" || exit
 247
 248            # Look at objects/info/alternates for rsync -- http will
 249            # support it natively and git native ones will do it on the remote
 250            # end.  Not having that file is not a crime.
 251            rsync -q "$remote/objects/info/alternates" \
 252                "$GIT_DIR/TMP_ALT" 2>/dev/null ||
 253                rm -f "$GIT_DIR/TMP_ALT"
 254            if test -f "$GIT_DIR/TMP_ALT"
 255            then
 256                resolve_alternates "$remote" <"$GIT_DIR/TMP_ALT" |
 257                while read alt
 258                do
 259                    case "$alt" in 'bad alternate: '*) die "$alt";; esac
 260                    echo >&2 "Getting alternate: $alt"
 261                    rsync -av --ignore-existing --exclude info \
 262                    "$alt" "$GIT_OBJECT_DIRECTORY/" || exit
 263                done
 264                rm -f "$GIT_DIR/TMP_ALT"
 265            fi
 266            rsync_slurped_objects=t
 267        }
 268        ;;
 269    *)
 270        # We will do git native transport with just one call later.
 271        continue ;;
 272    esac
 273
 274    append_fetch_head "$head" "$remote" \
 275        "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
 276
 277done
 278
 279case "$remote" in
 280http://* | https://* | rsync://* )
 281    ;; # we are already done.
 282*)
 283    IFS="       $LF"
 284    (
 285        git-fetch-pack "$remote" $rref || echo failed "$remote"
 286    ) |
 287    while read sha1 remote_name
 288    do
 289        case "$sha1" in
 290        failed)
 291                echo >&2 "Fetch failure: $remote"
 292                exit 1 ;;
 293        esac
 294        found=
 295        single_force=
 296        for ref in $refs
 297        do
 298            case "$ref" in
 299            +$remote_name:*)
 300                single_force=t
 301                not_for_merge=
 302                found="$ref"
 303                break ;;
 304            .+$remote_name:*)
 305                single_force=t
 306                not_for_merge=t
 307                found="$ref"
 308                break ;;
 309            .$remote_name:*)
 310                not_for_merge=t
 311                found="$ref"
 312                break ;;
 313            $remote_name:*)
 314                not_for_merge=
 315                found="$ref"
 316                break ;;
 317            esac
 318        done
 319        local_name=$(expr "$found" : '[^:]*:\(.*\)')
 320        append_fetch_head "$sha1" "$remote" \
 321                "$remote_name" "$remote_nick" "$local_name" "$not_for_merge"
 322    done || exit
 323    ;;
 324esac
 325
 326# If the original head was empty (i.e. no "master" yet), or
 327# if we were told not to worry, we do not have to check.
 328case ",$update_head_ok,$orig_head," in
 329*,, | t,* )
 330        ;;
 331*)
 332        curr_head=$(git-rev-parse --verify HEAD 2>/dev/null)
 333        if test "$curr_head" != "$orig_head"
 334        then
 335                git-update-ref HEAD "$orig_head"
 336                die "Cannot fetch into the current branch."
 337        fi
 338        ;;
 339esac