RIOT/dist/tools/git/git-cache

#!/bin/sh

git_cache() {
    git -C "${GIT_CACHE_DIR}" $*
}

git_cache_initialized() {
    local _git_dir="$(git_cache rev-parse --git-dir 2>/dev/null)"
    test "$_git_dir" = "." -o "$_git_dir" = ".git"
}

init() {
    set -e
    git_cache_initialized || {
        mkdir -p "${GIT_CACHE_DIR}"

        git_cache init --bare
        git_cache config core.compression 1
    }
    set +e
}

add() {
    local repo="$1"

    _locked "$GIT_CACHE_DIR/$name.addlock" _add "$repo"
}

_add() {
    set -e
    local repo="$1"
    local name="$(_remote_name $repo)"

    if ! is_cached "$repo"; then
        git_cache remote add "$name" "$repo"
        git_cache config --add remote.${name}.fetch "+refs/tags/*:refs/tags/${name}/*"
    else
        echo "git-cache: $url already in cache"
    fi
    set +e
}

_locked() {
    local lockfile="$1"
    shift

    (
        flock -w 600 9 || exit 1
        $*
    ) 9>"$lockfile"
}

update() {
    set -e

    local REMOTE=${1}
    if [ -n "$REMOTE" ]; then
        local REMOTES=$(_remote_name $REMOTE)
    else
        local REMOTES="$(git_cache remote show)"
    fi

    for remote in $REMOTES; do
        echo "git-cache: updating remote $remote"
        _locked "$GIT_CACHE_DIR/$remote.lock" git_cache --namespace $remote fetch -n $remote
    done

    set +e
}

is_cached() {
    set +e
    local url="$1"
    local REMOTES="$(git_cache remote show)"
    for remote in $REMOTES; do
        [ "$(git_cache ls-remote --get-url $remote)" = "$url" ] && return 0
    done
    set -e
    return 1
}

list() {
    local REMOTES="$(git_cache remote show)"
    for remote in $REMOTES; do
        echo "$(git_cache ls-remote --get-url $remote)"
    done
}

drop() {
    set -e
    local REMOTE=${1}
    [ -z "$REMOTE" ] && {
        echo "usage: git cache drop <url>"
        exit 1
    }
    local REMOTES="$(git_cache remote show)"
    for remote in $REMOTES; do
        [ "$(git_cache ls-remote --get-url $remote)" = "$REMOTE" ] && {
            git_cache remote remove $remote
            break
        }
    done
    set +e
}

_check_commit() {
    git_cache cat-file -e ${1}^{commit} 2>/dev/null
}

_remote_name() {
    echo "$*" | md5sum | cut -d\  -f1
}

_tag_to_sha1() {
    local out="$(git_cache log -n 1 --pretty=oneline $1 -- 2>/dev/null)"
    [ -n "$out" ] && echo $out | cut -f 1 -d" "
}

_check_tag_or_commit() {
    local SHA1=$1
    local REMOTE_NAME=$2

    if _check_commit $SHA1 ; then
        git_cache tag commit$SHA1 $SHA1 2> /dev/null || true # ignore possibly already existing tag
        echo "commit$SHA1"
    elif _tag_to_sha1 ${REMOTE_NAME}/$SHA1 > /dev/null; then
        echo "${REMOTE_NAME}/$SHA1"
    fi
}

clone() {
    set -e
    local REMOTE="${1}"
    local SHA1="${2}"
    local REMOTE_NAME="$(_remote_name $REMOTE)"
    local TARGET_PATH="${3}"

    [ -z "$TARGET_PATH" ] && TARGET_PATH="$(basename $REMOTE)"

    # make sure git won't ask for credentials
    export GIT_TERMINAL_PROMPT=0

    if git_cache_initialized; then
        if ! is_cached "$REMOTE"; then
            echo "git cache: auto-adding $REMOTE"
            add "$REMOTE"
        fi

        local tag="$(_check_tag_or_commit $SHA1 $REMOTE_NAME)"
        if [ -z "$tag" ]; then
            # commit / tag not in cache, try updating repo
            update "$REMOTE" || true
            tag="$(_check_tag_or_commit $SHA1 $REMOTE_NAME)"
        fi

        if [ -n "$tag" ]; then
            echo "git-cache: cloning from cache."
            git -c advice.detachedHead=false clone --reference "${GIT_CACHE_DIR}" --shared "${GIT_CACHE_DIR}" "${TARGET_PATH}" --branch $tag
            git -C "${TARGET_PATH}" fetch origin "refs/tags/${REMOTE_NAME}/*:refs/tags/*" > /dev/null
        else
            echo "git-cache: trying checkout from source"
            git clone --reference "${GIT_CACHE_DIR}" --shared "${REMOTE}" "${TARGET_PATH}"
            git -c advice.detachedHead=false -C "${TARGET_PATH}" checkout $SHA1
        fi
    else
            git clone "${REMOTE}" "${TARGET_PATH}"
            git -c advice.detachedHead=false -C "${TARGET_PATH}" checkout $SHA1
    fi
    set +e
}

usage() {
    echo "git cache uses a bare git repository containing all objects from multiple"
    echo "upstream git repositories."
    echo ""
    echo "usage:"
    echo ""
    echo "    git cache init                initialize git cache"
    echo "    git cache add <url>           add repository <url>"
    echo "    git cache list                list cached repositories"
    echo "    git cache drop <url>          drop repo from cache"
    echo "    git cache update [<url>]      fetch repo <url> (or all)"
    echo "    git cache clone <url> <SHA1>  clone repository <url> from cache"
    echo "    git cache show-path           print's the path that can be used as "
    echo "                                  '--reference' parameter"
    echo ""
    echo "To retrieve objects from cache (will use remote repository if needed):"
    echo '    git clone --reference $(git cache show-path) <repo>'
}

[ $# -eq 0 ] && {
    usage
    exit 1
}

ACTION=$1
shift 1

export GIT_CACHE_DIR=${GIT_CACHE_DIR:-${HOME}/.gitcache}

case $ACTION in
    init)
        init $*
        ;;
    add)
        add $*
        ;;
    update)
        update $*
        ;;
    list)
        list $*
        ;;
    drop)
        drop $*
        ;;
    show-path)
        echo ${GIT_CACHE_DIR}
        ;;
    clone)
        clone $*
        ;;
    *)
        usage
        ;;
esac