Project.pm: support project adoption

[girocco.git] / jobd / gc.sh

#!/bin/sh

# NOTE: additional options can be passed to git repack by specifying
#       them after the project name, for example:
#         gc.sh my-project -f

. @basedir@/shlib.sh

set -e

if [ $# -lt 1 ]; then
        echo "Usage: gc.sh projname [extra-repack-args]" >&2
        exit 1
fi

# packing options
packopts="--depth=50 --window=50 --window-memory=${var_window_memory:-1g}"
quiet=; [ -n "$show_progress" ] || quiet=-q

umask 002
[ "$cfg_permission_control" != "Hooks" ] || umask 000
clean_git_env

pidactive() {
        if _result="$(kill -0 "$1" 2>&1)"; then
                # process exists and we have permission to signal it
                return 0
        fi
        case "$_result" in *"not permitted"*)
                # we do not have permission to signal the process
                return 0
        esac
        # process does not exist
        return 1
}

createlock() {
        # A .lock file should only exist for much less than a second.
        # If we see a stale lock file (> 1h old), remove it and then,
        # just in case, wait 30 seconds for any process whose .lock
        # we might have just removed (it's racy) to finish doing what
        # should take much less than a second to do.
        _stalelock="$(find "$1.lock" -maxdepth 1 -mmin +60 -print 2>/dev/null || :)"
        if [ -n "$_stalelock" ]; then
                rm -f "$_stalelock"
                sleep 30
        fi
        for _try in p p n; do
                if (set -C; > "$1.lock") 2>/dev/null; then
                        echo "$1.lock"
                        return 0
                fi
                # delay and try again
                [ "$_try" != "p" ] || sleep 1
        done
        # cannot create lock file
        return 1
}

# The pre-receive script creates one ref log file per push but we want them to
# be coalesced into one ref log file per day.  We are guaranteed that any files
# we find to coalesce are NOT currently being written to since they are always
# written first as temporary files and then moved into place.  We attempt to
# transfer the most recent modification time to the coalesced log file which
# would step on its mod time if it were being written to directly, but if we
# find per-process ref log files then it must be a push project and the only
# thing that would write directly to the main per-day log file would be a
# mirror project so there's actually no conflict.
# Also, if the clock is wonky (or was futzed with) we may have both YYYYMMDD
# and YYYYMMDD.gz present in which case combine them into YYYYMMDD
coalesce_reflogs() {
        [ -d reflogs ] || return 0
        rm -f .gc_failed
        find reflogs -maxdepth 1 -type f -name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]" -print |
        while read -r rname; do
                if [ -e "$rname.gz" ]; then
                        if [ -s "$rname" ]; then
                                # Presumably the .gz file must have been created before the non-gz
                                # file since it had to be uncompressed at some point therefore
                                # we need to append the non-gz contents to it but keep the non-gz
                                # contents timestamp so we rename to YYYYMMDD_ which will sort first
                                # and be picked up in the next step if we are interrupted in the middle.
                                # If a YYYYMMDD_ file already exists we append to it and transfer the
                                # timestamp.  Finally we transfer the YYYYMMDD_ timestamp to the result
                                # and remove the YYYYMMDD_ temporary file leaving the result uncompressed.
                                if [ -e "${rname}_" ]; then
                                        cat "$rname" >>"${rname}_"
                                        touch -r "$rname" "${rname}_"
                                        rm -f "$rname"
                                        ! [ -e "$rname" ]
                                else
                                        mv "$rname" "${rname}_"
                                fi
                                gzip -d "$rname.gz" </dev/null
                                [ -e "$rname" ] && ! [ -e "$rname.gz" ]
                                cat "${rname}_" >>"$rname"
                                touch -r "${rname}_" "$rname"
                                rm -f "${rname}_"
                        else
                                # Just remove the empty file to resolve the problem
                                rm -f "$rname"
                        fi
                fi
        done
        find reflogs -maxdepth 1 -type f -name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]_*" -print | LC_ALL=C sort |
        while read -r rname; do
                logname="${rname%%_*}"
                # If someone's been futzing with the date, the file we want to
                # append to could already have been compressed, so we just uncompress
                # it here.  The previous block guarantees we do not have both a compressed
                # and uncompressed version present at the same time.
                if [ -e "$logname.gz" ]; then
                        gzip -d "$logname.gz" </dev/null
                        [ -e "$logname" ] && ! [ -e "$logname.gz" ]
                fi
                cat "$rname" >>"$logname"
                touch -r "$rname" "$logname"
                rm -f "$rname"
                if [ -e "$rname" ]; then
                        >.gc_failed
                        echo "! [$proj] failed to remove $rname" >&2
                        exit 1 # will only exit subshell created by "|"
                fi
        done
        ! [ -e .gc_failed ]
}

# Remove any files in reflogs that are older than $cfg_reflogs_lifetime days
prune_reflogs() {
        [ -d reflogs ] || return 0
        exp="$(( ${cfg_reflogs_lifetime:-1} * 1440 ))"
        [ $exp -gt 0 ] || exp=1440
        [ $exp -le 43200 ] || exp=43200
        find reflogs -maxdepth 1 -type f -mmin "+$exp" -print0 | xargs -0 rm -f
}

# Compact any reflogs that are not today's UTC date unless a .gz version exists
compact_reflogs() {
        [ -d reflogs ] || return 0
        _td="reflogs/$(TZ=UTC date '+%Y%m%d')"
        find reflogs -maxdepth 1 -type f -name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]" -print |
        while read -r rname; do
                [ "$rname" != "$_td" ] || continue
                ! [ -e "$rname.gz" ] || continue
                gzip -9 "$rname" </dev/null
        done
}

# return true if there's more than one objects/pack-<sha>.pack file or
# ANY sha-1 files in objects
is_dirty() {
        _packs=$(find objects/pack -type f -name "pack-$octet20.pack" -print | head -n 2 | LC_ALL=C wc -l)
        if [ $_packs != 1 ] && [ $_packs != 0 ]; then
                return 0
        fi
        _objs=$(find objects/$octet -type f -name "$octet19" -print 2>/dev/null | head -n 1 | LC_ALL=C wc -l)
        [ $_objs -ne 0 ]
}

# make sure combine-packs uses the correct Git executable
run_combine_packs() {
        PATH="$var_git_exec_path:$cfg_basedir/bin:$PATH" @basedir@/jobd/combine-packs.sh "$@"
}

# combine the input pack(s) into a new pack (or possibly packs if packSizeLimit set)
# input pack names are read from standard input one per line delimited by the first
# ':', ' ' or '\n' character on the line (which allows gfi-packs to be read directly)
# all arguments, if any, are passed to pack-objects as additional options
# returns non-zero on failure AND creates .gc_failed in that case
combine_packs() {
        rm -f .gc_failed
        find objects/pack -maxdepth 1 -type f -name '*.zap*' -print0 | xargs -0 rm -f
        run_combine_packs --replace "$@" $packopts --all-progress-implied $quiet --non-empty || {
                >.gc_failed
                return 1
        }
        return 0
}

# if the current directory is_gfi_mirror then repack all packs listed in gfi-packs
repack_gfi_packs() {
        [ -n "$gfi_mirror" ] || return 0
        [ -d objects/pack ] || { rm -f gfi-packs; return 0; }
        progress "~ [$proj] redeltifying poor quality git fast-import packs"
        combine_packs --ignore-missing --no-reuse-delta <gfi-packs
        rm -f gfi-packs
        return 0
}

# combine small packs into larger pack(s)
# we avoid any keep, bndl or bitmap packs
# if the optional argument is non-empty even a single small pack will be redeltad
combine_small_packs() {
        _didprogress=
        _minsmallpacks=2
        if [ -n "$1" ] && [ -n "$noreusedeltaopt" ]; then
                _minsmallpacks=1
        fi
        _lpo="--exclude-no-idx --exclude-keep --exclude-bitmap --exclude-bndl --quiet"
        _lpo="$_lpo --object-limit $var_redelta_threshold objects/pack"
        while
                _cnt="$(list_packs --count $_lpo || :)"
                test "${_cnt:-0}" -ge $_minsmallpacks
        do
                [ -n "$_didprogress" ] || {
                        progress "~ [$proj] combining small packs into a single larger pack"
                        _didprogress=1
                }
                _newp="$(list_packs $_lpo | combine_packs --names $noreusedeltaopt)"
                _newc="$(echo $(echo "$_newp" | LC_ALL=C wc -w))"
                # be paranoid and exit the loop if we haven't reduced the number of packs
                [ $_newc -lt $_cnt ] || break
                _minsmallpacks=2
        done
        return 0
}

# Unfortunately git-svn lacks the ability to store newly fetched revisions as a pack.
# However, the fetch code conveniently sets .svnpack just before it runs git-svn fetch
# so that it's easy to find all the objects that have been fetched by git-svn and
# combine them into a pack.  The --no-reuse-delta option is meaningless here since
# everything to be packed is a loose object and therefore not a delta so deltification
# will always take place.
make_svn_pack() {
        [ -f .svnpack ] && [ -n "$svn_mirror" ] || return 0
        rm -f .svnpackgc
        mv -f .svnpack .svnpackgc
        progress "~ [$proj] combining loose git-svn objects into a pack"
        _newp="$(find objects/$octet -maxdepth 1 -type f -newer .svnpackgc -name "$octet19" -print 2>/dev/null |
        LC_ALL=C awk -F / '{print $2 $3}' |
        run_combine_packs --objects --names $packopts --incremental --all-progress-implied $quiet --non-empty)" || {
                mv -f .svnpackgc .svnpack
                >.gc_failed
                return 1
        }
        if [ -n "$_newp" ]; then
                # remove the now-redundant loose objects -- this is always safe
                # even during a concurrent push because a reprepare_packed_git
                # will be triggered if an object that should be there is not
                # found thereby finding it in the new pack instead
                git prune-packed $quiet
        fi
        rm -f .svnpackgc
}

# HEADSHA="$(pack_is_complete /full/path/to/some.pack /full/path/to/packed-refs "$(cat HEAD)")"
pack_is_complete() {
        # Must have a matching .idx file and a non-empty packed-refs file
        [ -s "${1%.pack}.idx" ] || return 1
        [ -s "$2" ] || return 1
        _headsha=
        case "$3" in
                $octet20)
                        _headsha="$3"
                        ;;
                "ref: refs/"?*|"ref:refs/"?*|"refs/"?*)
                        _headmatch="${3#ref:}"
                        _headmatch="${_headmatch# }"
                        _headmatchpat="$(echo "$_headmatch" | LC_ALL=C sed -e 's/\([.$]\)/\\\1/g')"
                        _headsha="$(LC_ALL=C grep -e "^$octet20 $_headmatchpat\$" < "$2" | \
                                    LC_ALL=C cut -d ' ' -f 1)"
                        case "$_headsha" in $octet20) :;; *)
                                return 1
                        esac
                        ;;
                *)
                        # bad HEAD
                        return 1
        esac
        rm -rf pack_is_complete_test
        mkdir pack_is_complete_test
        mkdir pack_is_complete_test/refs
        mkdir pack_is_complete_test/objects
        mkdir pack_is_complete_test/objects/pack
        echo "$_headsha" > pack_is_complete_test/HEAD
        ln -s "$1" pack_is_complete_test/objects/pack/
        ln -s "${1%.pack}.idx" pack_is_complete_test/objects/pack/
        ln -s "$2" pack_is_complete_test/packed-refs
        _count="$(git --git-dir=pack_is_complete_test rev-list --count --all 2>/dev/null || :)"
        rm -rf pack_is_complete_test
        [ -n "$_count" ] || return 1
        [ "$_count" -gt 0 ] 2>/dev/null || return 1
        echo "$_headsha"
}

# On return a "$lockf" will have been created that must be removed when gc is done
lock_gc() {
        # be compatibile with gc.pid file from newer Git releases
        lockf=gc.pid
        hn="$(hostname)"
        active=
        if [ "$(createlock "$lockf")" ]; then
                # If $lockf is:
                #   1) less than 12 hours old
                #   2) contains two fields (pid hostname) NO trailing NL
                #   3) the hostname is different OR the pid is still alive
                # then we exit as another active process is holding the lock
                if [ "$(find "$lockf" -maxdepth 1 -mmin -720 -print 2>/dev/null)" ]; then
                        apid=
                        ahost=
                        read -r apid ahost ajunk < "$lockf" || :
                        if [ "$apid" ] && [ "$ahost" ]; then
                                if [ "$ahost" != "$hn" ] || pidactive "$apid"; then
                                        active=1
                                fi
                        fi
                fi
        else
                echo >&2 "[$proj] unable to create gc.pid.lock file"
                exit 1
        fi
        if [ -n "$active" ]; then
                rm -f "$lockf.lock"
                echo >&2 "[$proj] gc already running on machine '$ahost' pid '$apid'"
                exit 1
        fi
        printf "%s %s" "$$" "$hn" > "$lockf.lock"
        chmod 0664 "$lockf.lock"
        mv -f "$lockf.lock" "$lockf"
}

# Create a repack subdirectory such that running repack in it will pack the
# same things that a pack in the normal directory would except that the pack
# is guaranteed to be generated in an optimized order by adding a suitable
# synthesized ref in the refs/tags namespace (yes, pack-objects.c really does
# behave differently depending on the contents of the refs/tags namespace).
# Before calling this, pack-refs --all MUST be performed or the wrong pack
# will end up being made.
# If a ref deletion is pushed after making the repack subdir but before the
# the actual repack, the discarded objects will be packed -- no big deal,
# they'll get discarded the next time gc runs.
# If a fast-forward ref update is pushed after making the repack subdir but
# before the actual repack, it will be picked up and the new objects packed
# (subject to the normal git repack race about picking such updates up).
# If a non-fast-forward ref update is pushed after making the repack subdir but
# before the actual repack, it will be picked up like a fast-forward update but
# the discarded objects will be included like a ref deletion (until the next
# scheduled gc takes place).
make_repack_dir() {
        ! [ -d repack ] || rm -rf repack
        ! [ -d repack ] || { echo >&2 "[$proj] cannot remove repack subdirectory"; exit 1; }
        mkdir repack
        [ -d info ] || mkdir info
        ln -s ../config  repack/config
        ln -s ../info    repack/info
        ln -s ../objects repack/objects
        ln -s ../refs    repack/refs
        sed 's, refs/, refs/!/,' < packed-refs > repack/packed-refs
        optref="$(git rev-list -n 1 --all 2>/dev/null || :)"
        if [ -n "$optref" ]; then
                echo "$optref refs/tags/!" >> repack/packed-refs
                echo "$optref" > repack/HEAD
        else
                cat HEAD > repack/HEAD
        fi
}

# Remove any crud that's been left behind by interrupted operations
# that did not clean up after themselves
remove_crud() {
        # Remove any existing FETCH_HEAD
        # There can only be a FETCH_HEAD if we've been fetching, not if we've been
        # receiving pushes (those never create a FETCH_HEAD).
        # And if we're fetching because we're a mirror, we know we're not fetching right
        # now since jobd.pl never runs a project's fetch simultaneously with its gc.
        # Therefore any existing FETCH_HEAD is junk.  And it may be many megabytes if
        # there were a lot of refs.
        rm -f FETCH_HEAD

        # remove any existing pack_is_complete_test or repack subdirectories
        # If either exists when this function is called it's crud
        rm -rf pack_is_complete_test repack

        # Remove any stale pack remnants that are more than an hour old.
        # Stale pack fragments are defined as any pack-<sha1>.ext where .ext is NOT
        # .pack AND the corresponding .pack DOES NOT exist.  A bunch of stale
        # pack-<sha1>.idx files without their corresponding .pack files are worthless
        # and just waste space.  Normally there shouldn't be any remnants but actually
        # this can happen when things are interrupted at just the wrong time.
        # Note that the objects/pack directory is created by git init and should
        # always exist.
        find objects/pack -maxdepth 1 -type f -mmin +60 -name "pack-$octet20.?*" -print | \
        LC_ALL=C sed -e 's/^objects\/pack\/pack-//; s/\..*$//' | LC_ALL=C sort -u | \
        while read packsha; do
                [ ! -e "objects/pack/pack-$packsha.pack" ] || continue
                rm -f "objects/pack/pack-$packsha".?*
        done

        # Remove any stale tmp reflogs files that are more than one hour old.
        # Since they are created only while the pre-receive hook is running and
        # all it does is process a bunch of refs passed to it on standard input
        # it's inconceivable that it would ever take as much as an hour to run.
        if [ -d reflogs ]; then
                find reflogs -maxdepth 1 -type f -mmin +60 -name "tmp_*" -print0 | xargs -0 rm -f
        fi

        # Remove any stale pack .keep files that are more than 12 hours old.
        # We don't do anything to create any permanent pack .keep files, so they must
        # be remnants from some failed push or something.  Removing the .keep will
        # allow the pack to be properly repacked.
        find objects/pack -maxdepth 1 -type f -mmin +720 -name "pack-$octet20.keep" -print0 | xargs -0 rm -f

        # Remove any stale tmp_pack_*, tmp_idx_*, tmp_bitmap_*, packtmp-* or .tmp-*-pack* files
        # that are more than 12 hours old.
        find objects/pack -maxdepth 1 -type f -mmin +720 \( \
                -name "tmp_pack_?*" -o -name "tmp_idx_?*" -o -name "tmp_bitmap_?*" -o \
                -name "packtmp-?*" -o -name ".tmp-?*-pack*" \
                \) -print0 | xargs -0 rm -f

        # Remove any stale shallow_* files that are more than 12 hours old.
        # These can be left behind by Git >= 1.8.4.2 and < 2.0.0 when a client
        # requests a shallow clone.
        find . -maxdepth 1 -type f -mmin +720 -name "shallow_?*" -print0 | xargs -0 rm -f

        # Remove any stale *.temp files in the objects area that are more than 12 hours old.
        # This can be stale sha1.temp, or stale *.pack.temp so we kill all stale *.temp.
        find objects -type f -mmin +720 -name "*.temp" -print0 | xargs -0 rm -f

        # Remove any stale *.lock files in the htmlcache area that might have been left
        # behind after an abnormal exit during an attempt to update a cached file and
        # are more than 1 hour old.
        ! [ -d htmlcache ] || find htmlcache -type f -mmin +60 -name "*.lock" -print0 | xargs -0 rm -f

        # Remove any stale git-svn temp files that are more than 12 hours old.
        # The git-svn process creates temp files with random 10 character names
        # in the root of $GIT_DIR.  Unfortunately they do not have a recognizable
        # prefix, so we just have to kill any files with a 10-character name.  We
        # do this only for git-svn mirrors.  All characters are chosen from
        # [A-Za-z0-9_] so we can at least check that and fortunately the only
        # collision is 'FETCH_HEAD' but that shouldn't matter.
        # There may also be temp files with a Git_ prefix as well.
        if [ -n "$svn_mirror" ]; then
                _randchar='[A-Za-z0-9_]'
                _randchar2="$_randchar$_randchar"
                _randchar4="$_randchar2$_randchar2"
                _randchar10="$_randchar4$_randchar4$_randchar2"
                find . -maxdepth 1 -type f -mmin +720 -name "$_randchar10" -print0 | xargs -0 rm -f
                find . -maxdepth 1 -type f -mmin +720 -name "Git_*" -print0 | xargs -0 rm -f
        fi

        # Remove any stale fast_import_crash_<pid> files that are more than 3 days old.
        if [ -n "$gfi_mirror" ]; then
                find . -maxdepth 1 -type f -mmin +4320 -name "fast_import_crash_?*" -print0 | xargs -0 rm -f
        fi
}

#
## Garbage Collection Types
##
## There are two kinds of possible garbage collection (gc) operations:
##
## 1.  A normal, full gc
## 2.  A "mini" gc
##
## If the full garbage collection interval has expired (or gc has never been
## run), then a normal, full gc will take place.  Otherwise, a "mini" gc will
## take place if the file .needsgc exists.
##
## A "mini" gc is similar to "git gc --auto" in that it may not end up actually
## doing anything unless the right conditions are present so it's not a burden
## to run it often.  If the file .needsgc exists, a "mini" gc will occur at
## the next opportunity.
##
## Note, however, that the .nogc file suppresses ALL gc activity (normal or mini).
#

proj="${1%.git}"
shift
cd "$cfg_reporoot/$proj.git"
[ -d objects/pack ] || { rm -f gfi-packs; mkdir -p objects/pack; }
mirror_url="$(get_mirror_url)"
svn_mirror=
! is_svn_mirror_url "$mirror_url" || svn_mirror=1
gfi_mirror=
if [ -f gfi-packs -a -s gfi-packs ] && is_gfi_mirror_url "$mirror_url"; then
        gfi_mirror=1
fi

# If git config --bool --get girocco.redelta is explicitly false then automatic
# redelta when there are less than $var_redelta_threshold objects will be suppressed.
# On the other hand, if git config --get girocco.redelta is "always" then, on a full
# gc only, for the final repack, deltas will always be recomputed.
# This can be set on a per-project basis to avoid unusual pathological gc behavior.
# Setting this will hurt efficiency of the affected repository.
# Note that fast-import packs ALWAYS get new deltas regardless of this setting.
noreusedeltaopt="--no-reuse-delta"
[ "$(git config --bool --get girocco.redelta 2>/dev/null || :)" != "false" ] || noreusedeltaopt=
alwaysredelta=
[ "$(git config --get girocco.redelta 2>/dev/null || :)" != "always" ] || alwaysredelta=1

trap 'e=$?; rm -f .gc_in_progress; if [ $e != 0 ]; then echo "gc failed dir: $PWD" >&2; fi' EXIT
trap 'exit 130' INT
trap 'exit 143' TERM

# date -R is linux-only, POSIX equivalent is '+%a, %d %b %Y %T %z'
datefmt='+%a, %d %b %Y %T %z'

isminigc=
if check_interval lastgc $cfg_min_gc_interval; then
        if [ -e .needsgc ]; then
                isminigc=1
        else
                progress "= [$proj] garbage check skip (last at $(config_get lastgc))"
                exit 0
        fi
fi
if [ -e .nogc ]; then
        progress "x [$proj] garbage check disabled"
        exit 0
fi

if [ -n "$isminigc" ]; then
        # Perform a "mini" gc
        # Note that .delaygc is ignored here as that's only intended for full gc
        lock_gc
        rm -f .allowgc .needsgc
        remove_crud
        coalesce_reflogs
        prune_reflogs
        compact_reflogs
        miniactive=
        if [ -f .svnpack ] && [ -n "$svn_mirror" ]; then
                miniactive=1
                progress "+ [$proj] mini garbage check (`date`)"
                make_svn_pack
        fi
        if [ -z "$cfg_delay_gfi_redelta" ] && [ -n "$gfi_mirror" ]; then
                # $Girocco::Config::delay_gfi_redelta is false, force redeltification now
                if [ -z "$miniactive" ]; then
                        miniactive=1
                        progress "+ [$proj] mini garbage check (`date`)"
                fi
                repack_gfi_packs
        fi
        # If there aren't at least 10 non-keep, non-bitmap, non-bndl packs then
        # don't actually process them yet
        lpo="--exclude-no-idx --exclude-keep --exclude-bitmap --exclude-bndl --quiet"
        packcnt="$(list_packs --count $lpo objects/pack || :)"
        if [ "${packcnt:-0}" -ge 10 ]; then
                if [ -z "$miniactive" ]; then
                        miniactive=1
                        progress "+ [$proj] mini garbage check (`date`)"
                fi
                if [ -n "$gfi_mirror" ]; then
                        repack_gfi_packs
                        packcnt="$(list_packs --count $lpo objects/pack || :)"
                fi
                # if repack_gfi_packs dropped the pack count to < 10 don't combine
                if [ "${packcnt:-0}" -ge 10 ]; then
                        combine_small_packs
                        packcnt="$(list_packs --count $lpo objects/pack || :)"
                fi
                # if we still have more than 10 packs trigger a full gc
                if [ "${packcnt:-0}" -ge 10 ]; then
                        # We shouldn't be in a .delaygc state at this point, but if
                        # we are then nuke it because we really need a full gc now
                        rm -f .delaygc
                        git config --unset gitweb.lastgc
                        rm -f "$lockf"
                        progress "- [$proj] mini garbage check triggering full gc too many packs (`date`)"
                        exit 0
                fi
        fi
        rm -f "$lockf"
        if [ -n "$miniactive" ]; then
                git update-server-info
                progress "- [$proj] mini garbage check (`date`)"
        else
                progress "= [$proj] mini garbage check nothing but crud removal to do (`date`)"
        fi
        exit 0
fi

# Avoid unnecessary garbage collections:
#   1. If lastreceive is set and is older than lastgc
#   -AND-
#   2. We are not a fork (! -s alternates) -OR- lastparentgc is older than lastgc

# If lastgc is NOT set or lastreceive is NOT set we MUST run gc
# If we are a fork and lastparentgc is NOT set we MUST run gc

# If the repo is dirty after removing any crud we MUST run gc

gcstart="$(date "$datefmt")"
skipgc=
isfork=
[ -s objects/info/alternates ] && isfork=1
lastparentgcsecs=
[ -n "$isfork" ] && lastparentgcsecs="$(config_get_date_seconds lastparentgc || :)"
lastreceivesecs=
if lastreceivesecs="$(config_get_date_seconds lastreceive)" && \
   lastgcsecs="$(config_get_date_seconds lastgc)" && \
   [ $lastreceivesecs -lt $lastgcsecs ]; then
        # We've run gc since we last received, so maybe we can skip,
        # check if not fork or fork and lastparentgc < lastgc
        if [ -n "$isfork" ]; then
                if [ -n "$lastparentgcsecs" ] && \
                   [ $lastparentgcsecs -lt $lastgcsecs ]; then
                        # We've run gc since our parent ran gc so we can skip
                        skipgc=1
                fi
        else
                # We don't have any alternates (we're not a forK) so we can skip
                skipgc=1
        fi
fi

# Prevent any other simultaneous gc operations
lock_gc

# At this point, if .allowgc exists, it's now crud to be removed
rm -f .allowgc

# Ideally we would do this in post-receive, but that would mean duplicating the
# logic so it's available in the chroot jail and that's highly undesirable
# Instead, since the first gc will be triggered immediately following the first
# push, we do the check here as it's quick and harmless if HEAD is already valid
check_and_set_head || :

# Always get rid of crud
remove_crud

# Always perform reflogs maintenance
coalesce_reflogs
prune_reflogs
compact_reflogs

# Run 'git svn gc' now for svn mirrors
if [ -n "$svn_mirror" ]; then
        git svn gc || :
fi

# Skip the actual gc if .delaygc is set
if [ -e .delaygc ]; then
        progress "x [$proj] garbage check delayed (except for crud removal)"
        rm -f "$lockf"
        exit 0
fi

# Do not skip gc if the repo is dirty
if [ -n "$skipgc" ] && ! is_dirty; then
        progress "= [$proj] garbage check nothing but crud removal to do (`date`)"
        config_set lastgc "$gcstart"
        rm -f "$lockf"
        exit 0
fi

bumptime=
if [ -n "$isfork" ] && [ -z "$lastparentgcsecs" ]; then
        # set lastparentgc and then update gcstart to be at least 1 second later
        config_set lastparentgc "$gcstart"
        bumptime=1
fi
if [ -z "$lastreceivesecs" ]; then
        # set lastreceive and then update gcstart to be at least 1 second later
        config_set lastreceive "$gcstart"
        bumptime=1
fi
if [ -n "$bumptime" ]; then
        sleep 1
        gcstart="$(date "$datefmt")"
fi

progress "+ [$proj] garbage check (`date`)"

newdeltas=
[ -z "$alwaysredelta" ] || newdeltas=-f
if [ -z "$newdeltas" ] && [ -n "$gfi_mirror" ]; then
        if [ $(list_packs --exclude-no-idx --count objects/pack) -le \
             $(list_packs --exclude-no-idx --count --quiet --only gfi-packs) ]; then
                # Don't bother with repack_gfi_packs since everything's being repacked
                newdeltas=-f
        fi
fi
if [ -z "$newdeltas" ] && [ -n "$noreusedeltaopt" ] && \
   [ $(list_packs --exclude-no-idx --count-objects objects/pack) -le $var_redelta_threshold ]; then
        # There aren't enough objects to worry about so just redelta to get the best pack
        newdeltas=-f
fi
if [ -z "$newdeltas" ]; then
        # Since we're not going to recompute deltas overall, we need to do the
        # "mini" maintenance so that we can get more optimal deltas
        [ -z "$noreusedeltaopt" ] || make_svn_pack
        repack_gfi_packs
        force_single_pack_redelta=
        [ -n "$gfi_mirror" ] || [ -n "$svn_mirror" ] || force_single_pack_redelta=1
        [ -z "$noreusedeltaopt" ] || combine_small_packs $force_single_pack_redelta
fi

#
## Safe Pruning In Forks
##
## We are about to perform garbage collection.  We do NOT use the "git gc"
## command directly as it does not provide enough control over the fine details
## that we require.  However, we DO maintain a "gc.pid" file during our garbage
## collection so that a simultaneous "git gc" by an administrator will be
## blocked (and similarly we refuse to start garbage collection if we cannot
## create the "gc.pid" file).  When we say "gc" in the below description we are
## referring to our "gc.sh" script, NOT the "git gc" command.
##
## If the project we are running garbage collection (gc) on has any forks we
## must be careful not to remove any objects that while no longer referenced by
## this project (the parent) are still referenced by one or more forks (the
## children) otherwise the children will become corrupt and we can't abide
## corrupt children.
##
## One way to accomplish this is to simply hard-link all currently existing
## loose objects and packs in the parent into all the children that refer to the
## parent (via a line in their objects/info/alternates file) before beginning
## the gc operation and then relying on a subsequent gc in the child to clean up
## any excess objects/packs.  We used to use this strategy but it's very
## inefficient because:
##
##   1. The disk space used by the old pack(s)/object(s) will not be reclaimed
##      until all children (and their children, if any) run gc by which time
##      it's quite possible the topmost parent will have run gc again and
##      hard-linked yet another old pack down to its children (not to mention
##      loose objects).
##
##   2. As we are now using the "-A" option with "git repack", any new objects
##      in the parent that are not referenced by children will continually get
##      exploded out of the hard-linked pack in the children whenever the
##      children run gc.
##
##   3. To avoid suboptimal and/or unnecessarily many packs being hard-linked
##      into child forks, we must run the "mini" gc maintenance before we
##      perform the hard-linking into the children which provides yet another
##      source of inefficiency.
##
## Since we are using the "-A" option to "git repack" (that was not always the
## case) to guarantee we can access old ref values for long enough to send out
## a meaningful mail.sh notification, we now have another, more efficient,
## option available to prevent corruption of child forks that continue to refer
## to objects that are no longer reachable from any ref in the parent.
##
## The only things that need be copied (or hard-linked) into the child fork(s)
## are those objects that have become unreachable from any ref in the parent.
## They are the only things that could ever be removed by "git prune" and
## therefore the only things we need to prevent the loss of in order to avoid
## corruption of the child fork(s).
##
## Therefore we now use the following strategy instead to avoid excessive disk
## use and lots of unnecessary loose objects in child forks:
##
##   1. Run "git repack -A -d -l" in the parent BEFORE doing anything about
##      child forks.
##
##   2. Hard-link all remaining existing loose objects in the parent into the
##      immediate child forks.
##
##   3. Now run "git prune" in the parent.
##
## With this new strategy we avoid the need to run any "mini" gc maintenance
## before copying (or hard-linking) anything down to the child forks.
## Furthermore, only when the parent performs a non-fast-forward update will
## anything ever be transferred to the children leaving them unperturbed in the
## vast majority of cases.  Finally, even if the parent references objects the
## children do not, those objects will no longer continually end up in the
## children as unreachable loose objects after the children run gc.
#

git pack-refs --all
make_repack_dir
touch .gc_in_progress
rm -f .gc_failed bundles/*
rm -f objects/pack/pack-*.bndl
# We use the -A option with git repack so that unreachable objects can live
# on for a time as loose objects.  This is particularly helpful if we just
# happen to be in the process of sending out a ref update for a ref that was
# force updated and the old ref value would have otherwise been removed by
# repack because it was now unreachable.  Admittedly the window for gc to run
# and do that before we manage to send out the ref update is not large, but
# it would not be difficult to create such a situation.  Unfortunately, when
# Git unpacks these unreachable objects it will give them the modification
# time of the *.pack file they came out of.  This could be very, very old.
# If that happens, the subsequent git prune --expire some_time_ago will still
# remove the object(s) and our pending ref update will still lose out.
# To prevent this from happening and to get the behavior we want, we now
# touch the modification time of all pack-<sha>.pack files so that any
# loosened objects get a current time.  Git does not provide any other
# mechanism to do this.  We do not want to just touch all loose objects
# left after the repack because that would cause objects that were loosened
# previously to live on which we definitely do not want.
list_packs --exclude-no-idx objects/pack | xargs touch -c 2>/dev/null || :
# We wish to keep deltas from our last full pack so if we're not redeltaing
# then make sure the .pack associated with the .bitmap has a newer mod time
# (If there is no .bitmap then touch the pack with the most objects instead.)
if [ -z "$newdeltas" ]; then
        bmpack="$(list_packs --exclude-no-bitmap --exclude-no-idx --max-matches 1 objects/pack)"
        [ -n "$bmpack" ] || bmpack="$(list_packs --exclude-no-idx --max-matches 1 --object-limit -1 --include-boundary objects/pack)"
        if [ -n "$bmpack" ] && [ -f "$bmpack" -a -s "$bmpack" ]; then
                sleep 1
                touch -c "$bmpack" 2>/dev/null || :
        fi
fi
# The git repack command only supports bitmaps if all objects are being packed.
# While it is theoretically possible that a project with a non-empty alternates
# file ends up packing all objects (because it does not actually use any of the
# objects found in the alternates), it's very unlikely.  And, in the unlikely
# event that did occur, clients would see a message about only using one bitmap
# because Git can only use one bitmap at a time and at least one of the
# alternates is bound to have a bitmap.  Therefore if we see a non-empty
# alternates file, we disable writing bitmaps which avoids the warning and any
# possibility of a client warning as well.
nobm=
[ -z "$var_have_git_172" ] || ! [ -s objects/info/alternates ] || \
        nobm='-c repack.writebitmaps=false -c pack.writebitmaps=false'
progress "~ [$proj] running full gc repack${nobm:+ (bitmaps disabled)}"
cd repack
# We run git repack from the repack subdirectory so we can force optimized packs
# to be generated even for repositories that do not have any tagged commits
git $nobm repack $packopts -A -d -l $quiet $newdeltas $@
cd ..
rm -rf repack
[ ! -e .gc_failed ] || exit 1
# These, if they exist, are now meaningless and need to be removed
rm -f gfi-packs .needsgc .svnpack .svnpackgc
allpacks="$(echo objects/pack/pack-$octet20.pack)"
curhead="$(cat HEAD)"
pkrf=
[ ! -e packed-refs ] || pkrf=packed-refs
eval "reposizek=$(( $(echo 0 $(du -k $pkrf $allpacks 2>/dev/null | LC_ALL=C awk '{print $1}') | \
        LC_ALL=C sed -e 's/ / + /g') ))"
git update-server-info
# The -A option to `git repack` may have caused some loose objects to pop
# out of their packs.  We must make these objects group writable so that they
# can be freshened by other pushers.  Technically we need only do this for
# push projects but to enable mirror projects to be more easily converted to
# push projects, we go ahead and do it for all projects.
{ find objects/$octet -type f -name "$octet19" -print0 | xargs -0 chmod ug+w || :; } 2>/dev/null

if has_forks "$proj"; then
        progress "~ [$proj] hard-linking loose objects into immediate child forks"
        # We have to update the lastparentgc time in the child forks even if they do not get any
        # new "loose objects" because they need to run gc just in case the parent now has some
        # objects that used to only be in the child so they can be removed from the child.
        # For example, a "patch" might be developed first in a fork and then later accepted into
        # the parent in which case the objects making up the patch in the child fork are now
        # redundant (since they're now in the parent as well) and need to be removed from the
        # child fork which can only happen if the child fork runs gc.
        forkdir="$proj"
        # It is enough to copy objects just one level down and get_repo_list
        # takes a regular expression (which is automatically prefixed with '^')
        # so we can easily match forks exactly one level down from this project
        get_repo_list "$forkdir/[^/]*:" |
                while read fork; do
                        # Ignore forks that do not exist or are symbolic links
                        [ ! -L "$cfg_reporoot/$fork.git" -a -d "$cfg_reporoot/$fork.git" ] || \
                                continue
                        # Or do not have a non-zero length alternates file
                        [ -s "$cfg_reporoot/$fork.git/objects/info/alternates" ] || \
                                continue
                        # Match objects in parent project
                        for d in objects/$octet; do
                                [ "$d" != "objects/$octet" ] || continue
                                mkdir -p "$cfg_reporoot/$fork.git/$d"
                                find "$d" -maxdepth 1 -type f -name "$octet19" -print0 |
                                        xargs -0 "$var_sh_bin" -c 'ln -f "$@" '"'$cfg_reporoot/$fork.git/$d/'" sh || :
                        done
                        # Update the fork's lastparentgc date (must be current, not $gcstart)
                        git --git-dir="$cfg_reporoot/$fork.git" config \
                                gitweb.lastparentgc "$(date "$datefmt")"
                done
fi

# The git prune command does not take a -q or --quiet but started outputting
# 'Checking connectivity' progress messages in v1.7.9.  However, we can
# suppress those by piping through cat as it only activates the progress
# messages when stderr is a tty.  We only expire loose objects older than one
# day just in case there's some pending action (such as sending out a ref
# update) in progress that might want to examine them.  This may leave us with
# loose objects.  That's okay because at the next gc interval, we will always
# run gc if we see any loose objects regardless of whether or not we've seen
# any updates or we've received new linked objects from our parent.  Note that
# in order to keep loose objects that just recently became unreferenced but
# have a very old modification date around we rely on some help from both the
# update.sh and hooks/pre-receive scripts.  Furthermore, since Git v2.2.0
# (d3038d22 prune: keep objects reachable from recent objects) an unreachable
# object that would otherwise be pruned (because it's too old) will be kept
# alive by an unreachable object that refers to it that's not old enough to
# be pruned yet.
prunecmd='git prune --expire 1_day_ago'
[ -n "$show_progress" ] || \
prunecmd="{ $prunecmd 2>&1 || touch .gc_failed; } | cat"
progress "~ [$proj] pruning expired unreachable loose objects"
eval "$prunecmd"
[ ! -e .gc_failed ] || exit 1

# darcs:// mirrors have a xxx.log file that will grow endlessly
# if this is a mirror and the file exists, shorten it to 10000 lines
# also take this opportunity to optimize the darcs repo
if [ ! -e .nofetch ] && [ -n "$cfg_mirror" ]; then
        url="$(config_get baseurl || :)"
        case "$url" in darcs://*)
                if [ -n "$cfg_mirror_darcs" ]; then
                        url="${url%/}"
                        basedarcs="$(basename "${url#darcs:/}")"
                        if [ -f "$basedarcs.log" ]; then
                                tail -n 10000 "$basedarcs.log" > "$basedarcs.log.$$"
                                mv -f "$basedarcs.log.$$" "$basedarcs.log"
                        fi
                        if [ -d "$basedarcs.darcs" ]; then
                                (
                                        cd "$basedarcs.darcs"
                                        # without show_progress suppress non-error output
                                        [ -n "$show_progress" ] || exec >/dev/null
                                        # Note that this does not optimize _darcs/inventories/ :(
                                        darcs optimize || :
                                )
                        fi
                fi
        esac
fi

# Create a matching .bndl header file for the all-in-one pack we just created
# but only if we're not a fork (otherwise the bundle would not be complete)
# and we are running at least Git version 1.7.2 (pack_is_complete always fails otherwise)
if [ ! -s objects/info/alternates ] && [ -n "$var_have_git_172" ]; then
        # There should only be one pack in $allpacks but if there was a
        # simultaneous push...
        # The one we just created will have a .idx and will NOT have a .keep
        progress "~ [$proj] creating downloadble bundle header"
        pkfound=
        pkhead=
        for pk in $allpacks; do
                [ -s "$pk" ] || continue
                pkbase="${pk%.pack}"
                [ -s "$pkbase.idx" ] || continue
                [ ! -e "$pkbase.keep" ] || continue
                if pkhead="$(pack_is_complete "$PWD/$pk" "$PWD/packed-refs" "$curhead")"; then
                        pkfound="$pkbase"
                        break;
                fi
        done
        if [ -n "$pkfound" -a -n "$pkhead" ]; then
                {
                        echo "# v2 git bundle"
                        LC_ALL=C sed -ne "/^$octet20 refs\/[^ $tab]*\$/ p" < packed-refs
                        echo "$pkhead HEAD"
                        echo ""
                } > "$pkbase.bndl"
                bndletag="$("$cfg_basedir/bin/rangecgi" --etag -m 1 "$pkbase.bndl" "$pkbase.pack" || :)"
                bndlsha="$(printf '%s' "$bndletag" | git hash-object --stdin || :)"
                if [ -n "$bndletag" ]; then
                        case "$bndlsha" in $octet20)
                                bndlshatrailer="${bndlsha#????????}"
                                bndlshaprefix="${bndlsha%$bndlshatrailer}"
                                bndlname="$(TZ=UTC date +%Y%m%d_%H%M%S)-${bndlshaprefix:-0}"
                                [ -d bundles ] || mkdir bundles
                                echo "${pkbase#objects/pack/}.bndl" > "bundles/$bndlname"
                                echo "${pkbase#objects/pack/}.pack" >> "bundles/$bndlname"
                                ln -s -f -n "$bndlname" bundles/latest
                        esac
                fi
        fi
fi

# Record the size of this repo as the sum of its *.pack sizes as 1024-byte blocks
config_set_raw girocco.reposizek "${reposizek:-0}"

# We use $gcstart here to avoid a race where a push occurs during the gc itself
# and the next future gc could be incorrectly skipped if we used the current
# timestamp here instead
config_set lastgc "$gcstart"
rm -f "$lockf"

progress "- [$proj] garbage check (`date`)"