jobd/gc.sh

   1 #!/bin/sh
   2
   3 # NOTE: additional options can be passed to git repack by specifying
   4 #       them after the project name, for example:
   5 #         gc.sh my-project -f
   6
   7 . @basedir@/shlib.sh
   8
   9 set -e
  10
  11 if [ $# -lt 1 ]; then
  12         echo "Usage: gc.sh projname [extra-repack-args]" >&2
  13         exit 1
  14 fi
  15
  16 # packing options
  17 packopts="--depth=50 --window=50 --window-memory=${var_window_memory:-1g}"
  18 quiet=; [ -n "$show_progress" ] || quiet=-q
  19
  20 umask 002
  21 [ "$cfg_permission_control" != "Hooks" ] || umask 000
  22 clean_git_env
  23
  24 pidactive() {
  25         if _result="$(kill -0 "$1" 2>&1)"; then
  26                 # process exists and we have permission to signal it
  27                 return 0
  28         fi
  29         case "$_result" in *"not permitted"*)
  30                 # we do not have permission to signal the process
  31                 return 0
  32         esac
  33         # process does not exist
  34         return 1
  35 }
  36
  37 createlock() {
  38         # A .lock file should only exist for much less than a second.
  39         # If we see a stale lock file (> 1h old), remove it and then,
  40         # just in case, wait 30 seconds for any process whose .lock
  41         # we might have just removed (it's racy) to finish doing what
  42         # should take much less than a second to do.
  43         _stalelock="$(find "$1.lock" -maxdepth 1 -mmin +60 -print 2>/dev/null)" || :
  44         if [ -n "$_stalelock" ]; then
  45                 rm -f "$_stalelock"
  46                 sleep 30
  47         fi
  48         for _try in p p n; do
  49                 if (set -C; >"$1.lock") 2>/dev/null; then
  50                         echo "$1.lock"
  51                         return 0
  52                 fi
  53                 # delay and try again
  54                 [ "$_try" != "p" ] || sleep 1
  55         done
  56         # cannot create lock file
  57         return 1
  58 }
  59
  60 # The pre-receive script creates one ref log file per push but we want them to
  61 # be coalesced into one ref log file per day.  We are guaranteed that any files
  62 # we find to coalesce are NOT currently being written to since they are always
  63 # written first as temporary files and then moved into place.  We attempt to
  64 # transfer the most recent modification time to the coalesced log file which
  65 # would step on its mod time if it were being written to directly, but if we
  66 # find per-process ref log files then it must be a push project and the only
  67 # thing that would write directly to the main per-day log file would be a
  68 # mirror project so there's actually no conflict.
  69 # Also, if the clock is wonky (or was futzed with) we may have both YYYYMMDD
  70 # and YYYYMMDD.gz present in which case combine them into YYYYMMDD
  71 coalesce_reflogs() {
  72         [ -d reflogs ] || return 0
  73         rm -f .gc_failed
  74         find reflogs -maxdepth 1 -type f -name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]" -print |
  75         while read -r rname; do
  76                 if [ -e "$rname.gz" ]; then
  77                         if [ -s "$rname" ]; then
  78                                 # Presumably the .gz file must have been created before the non-gz
  79                                 # file since it had to be uncompressed at some point therefore
  80                                 # we need to append the non-gz contents to it but keep the non-gz
  81                                 # contents timestamp so we rename to YYYYMMDD_ which will sort first
  82                                 # and be picked up in the next step if we are interrupted in the middle.
  83                                 # If a YYYYMMDD_ file already exists we append to it and transfer the
  84                                 # timestamp.  Finally we transfer the YYYYMMDD_ timestamp to the result
  85                                 # and remove the YYYYMMDD_ temporary file leaving the result uncompressed.
  86                                 if [ -e "${rname}_" ]; then
  87                                         cat "$rname" >>"${rname}_"
  88                                         touch -r "$rname" "${rname}_"
  89                                         rm -f "$rname"
  90                                         ! [ -e "$rname" ]
  91                                 else
  92                                         mv "$rname" "${rname}_"
  93                                 fi
  94                                 gzip -d "$rname.gz" </dev/null
  95                                 [ -e "$rname" ] && ! [ -e "$rname.gz" ]
  96                                 cat "${rname}_" >>"$rname"
  97                                 touch -r "${rname}_" "$rname"
  98                                 rm -f "${rname}_"
  99                         else
 100                                 # Just remove the empty file to resolve the problem
 101                                 rm -f "$rname"
 102                         fi
 103                 fi
 104         done
 105         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 |
 106         while read -r rname; do
 107                 logname="${rname%%_*}"
 108                 # If someone's been futzing with the date, the file we want to
 109                 # append to could already have been compressed, so we just uncompress
 110                 # it here.  The previous block guarantees we do not have both a compressed
 111                 # and uncompressed version present at the same time.
 112                 if [ -e "$logname.gz" ]; then
 113                         gzip -d "$logname.gz" </dev/null
 114                         [ -e "$logname" ] && ! [ -e "$logname.gz" ]
 115                 fi
 116                 cat "$rname" >>"$logname"
 117                 touch -r "$rname" "$logname"
 118                 rm -f "$rname"
 119                 if [ -e "$rname" ]; then
 120                         >.gc_failed
 121                         echo "! [$proj] failed to remove $rname" >&2
 122                         exit 1 # will only exit subshell created by "|"
 123                 fi
 124         done
 125         ! [ -e .gc_failed ]
 126 }
 127
 128 # Remove any files in reflogs that are older than $cfg_reflogs_lifetime days
 129 prune_reflogs() {
 130         [ -d reflogs ] || return 0
 131         exp="$(( ${cfg_reflogs_lifetime:-1} * 1440 ))"
 132         [ $exp -gt 0 ] || exp=1440
 133         [ $exp -le 43200 ] || exp=43200
 134         find reflogs -maxdepth 1 -type f -mmin "+$exp" -exec rm -f '{}' + || :
 135 }
 136
 137 # Compact any reflogs that are not today's UTC date unless a .gz version exists
 138 compact_reflogs() {
 139         [ -d reflogs ] || return 0
 140         _td="reflogs/$(TZ=UTC date '+%Y%m%d')"
 141         find reflogs -maxdepth 1 -type f -name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]" -print |
 142         while read -r rname; do
 143                 [ "$rname" != "$_td" ] || continue
 144                 ! [ -e "$rname.gz" ] || continue
 145                 gzip -9 "$rname" </dev/null
 146         done
 147 }
 148
 149 # return true if there's more than one objects/pack-<sha>.pack file or
 150 # ANY sha-1 files in objects
 151 is_dirty() {
 152         _packs=$(find objects/pack -type f -name "pack-$octet20.pack" -print | head -n 2 | LC_ALL=C wc -l)
 153         if [ $_packs != 1 ] && [ $_packs != 0 ]; then
 154                 return 0
 155         fi
 156         _objs=$(find objects/$octet -type f -name "$octet19" -print 2>/dev/null | head -n 1 | LC_ALL=C wc -l)
 157         [ $_objs -ne 0 ]
 158 }
 159
 160 # make sure combine-packs uses the correct Git executable
 161 run_combine_packs() {
 162         PATH="$var_git_exec_path:$cfg_basedir/bin:$PATH" @basedir@/jobd/combine-packs.sh "$@"
 163 }
 164
 165 # combine the input pack(s) into a new pack (or possibly packs if packSizeLimit set)
 166 # input pack names are read from standard input one per line delimited by the first
 167 # ':', ' ' or '\n' character on the line (which allows gfi-packs to be read directly)
 168 # all arguments, if any, are passed to pack-objects as additional options
 169 # returns non-zero on failure AND creates .gc_failed in that case
 170 combine_packs() {
 171         rm -f .gc_failed
 172         find objects/pack -maxdepth 1 -type f -name '*.zap*' -exec rm -f '{}' + || :
 173         run_combine_packs --replace "$@" $packopts --all-progress-implied $quiet --non-empty || {
 174                 >.gc_failed
 175                 return 1
 176         }
 177         return 0
 178 }
 179
 180 # if the current directory is_gfi_mirror then repack all packs listed in gfi-packs
 181 repack_gfi_packs() {
 182         [ -n "$gfi_mirror" ] || return 0
 183         [ -d objects/pack ] || { rm -f gfi-packs; return 0; }
 184         progress "~ [$proj] redeltifying poor quality git fast-import packs"
 185         combine_packs --ignore-missing --no-reuse-delta <gfi-packs
 186         rm -f gfi-packs
 187         return 0
 188 }
 189
 190 # combine small packs into larger pack(s)
 191 # we avoid any keep, bndl or bitmap packs
 192 # if the optional argument is non-empty even a single small pack will be redeltad
 193 combine_small_packs() {
 194         _didprogress=
 195         _minsmallpacks=2
 196         if [ -n "$1" ] && [ -n "$noreusedeltaopt" ]; then
 197                 _minsmallpacks=1
 198         fi
 199         _lpo="--exclude-no-idx --exclude-keep --exclude-bitmap --exclude-bndl --quiet"
 200         _lpo="$_lpo --object-limit $var_redelta_threshold objects/pack"
 201         while
 202                 _cnt="$(list_packs --count $_lpo)" || :
 203                 test "${_cnt:-0}" -ge $_minsmallpacks
 204         do
 205                 [ -n "$_didprogress" ] || {
 206                         progress "~ [$proj] combining small packs into a single larger pack"
 207                         _didprogress=1
 208                 }
 209                 _newp="$(list_packs $_lpo | combine_packs --names $noreusedeltaopt)"
 210                 _newc="$(( $(echo "$_newp" | LC_ALL=C wc -w) ))"
 211                 # be paranoid and exit the loop if we haven't reduced the number of packs
 212                 [ $_newc -lt $_cnt ] || break
 213                 _minsmallpacks=2
 214         done
 215         return 0
 216 }
 217
 218 # Unfortunately git-svn lacks the ability to store newly fetched revisions as a pack.
 219 # However, the fetch code conveniently sets .svnpack just before it runs git-svn fetch
 220 # so that it's easy to find all the objects that have been fetched by git-svn and
 221 # combine them into a pack.  The --no-reuse-delta option is meaningless here since
 222 # everything to be packed is a loose object and therefore not a delta so deltification
 223 # will always take place.
 224 make_svn_pack() {
 225         [ -f .svnpack ] && [ -n "$svn_mirror" ] || return 0
 226         rm -f .svnpackgc
 227         mv -f .svnpack .svnpackgc
 228         progress "~ [$proj] combining loose git-svn objects into a pack"
 229         _newp="$(find objects/$octet -maxdepth 1 -type f -newer .svnpackgc -name "$octet19" -print 2>/dev/null |
 230         LC_ALL=C awk -F / '{print $2 $3}' |
 231         run_combine_packs --objects --names $packopts --incremental --all-progress-implied $quiet --non-empty)" || {
 232                 mv -f .svnpackgc .svnpack
 233                 >.gc_failed
 234                 return 1
 235         }
 236         if [ -n "$_newp" ]; then
 237                 # remove the now-redundant loose objects -- this is always safe
 238                 # even during a concurrent push because a reprepare_packed_git
 239                 # will be triggered if an object that should be there is not
 240                 # found thereby finding it in the new pack instead
 241                 git prune-packed $quiet
 242         fi
 243         rm -f .svnpackgc
 244 }
 245
 246 # HEADSHA="$(pack_is_complete /full/path/to/some.pack /full/path/to/packed-refs "$(cat HEAD)")"
 247 pack_is_complete() {
 248         # Must have a matching .idx file and a non-empty packed-refs file
 249         [ -s "${1%.pack}.idx" ] || return 1
 250         [ -s "$2" ] || return 1
 251         _headsha=
 252         case "$3" in
 253                 $octet20)
 254                         _headsha="$3"
 255                         ;;
 256                 "ref: refs/"?*|"ref:refs/"?*|"refs/"?*)
 257                         _headmatch="${3#ref:}"
 258                         _headmatch="${_headmatch# }"
 259                         _headmatchpat="$(echo "$_headmatch" | LC_ALL=C sed -e 's/\([.$]\)/\\\1/g')"
 260                         _headsha="$(LC_ALL=C grep -e "^$octet20 $_headmatchpat\$" <"$2" |
 261                                     LC_ALL=C cut -d ' ' -f 1)"
 262                         case "$_headsha" in $octet20) :;; *)
 263                                 return 1
 264                         esac
 265                         ;;
 266                 *)
 267                         # bad HEAD
 268                         return 1
 269         esac
 270         rm -rf pack_is_complete_test
 271         mkdir pack_is_complete_test
 272         mkdir pack_is_complete_test/refs
 273         mkdir pack_is_complete_test/objects
 274         mkdir pack_is_complete_test/objects/pack
 275         echo "$_headsha" >pack_is_complete_test/HEAD
 276         ln -s "$1" pack_is_complete_test/objects/pack/
 277         ln -s "${1%.pack}.idx" pack_is_complete_test/objects/pack/
 278         ln -s "$2" pack_is_complete_test/packed-refs
 279         _count="$(git --git-dir=pack_is_complete_test rev-list --count --all 2>/dev/null)" || :
 280         rm -rf pack_is_complete_test
 281         [ -n "$_count" ] || return 1
 282         [ "$_count" -gt 0 ] 2>/dev/null || return 1
 283         echo "$_headsha"
 284 }
 285
 286 # On return a "$lockf" will have been created that must be removed when gc is done
 287 lock_gc() {
 288         # be compatibile with gc.pid file from newer Git releases
 289         lockf=gc.pid
 290         hn="$(hostname)"
 291         active=
 292         if [ "$(createlock "$lockf")" ]; then
 293                 # If $lockf is:
 294                 #   1) less than 12 hours old
 295                 #   2) contains two fields (pid hostname) NO trailing NL
 296                 #   3) the hostname is different OR the pid is still alive
 297                 # then we exit as another active process is holding the lock
 298                 if [ "$(find "$lockf" -maxdepth 1 -mmin -720 -print 2>/dev/null)" ]; then
 299                         apid=
 300                         ahost=
 301                         read -r apid ahost ajunk <"$lockf" || :
 302                         if [ "$apid" ] && [ "$ahost" ]; then
 303                                 if [ "$ahost" != "$hn" ] || pidactive "$apid"; then
 304                                         active=1
 305                                 fi
 306                         fi
 307                 fi
 308         else
 309                 echo >&2 "[$proj] unable to create gc.pid.lock file"
 310                 exit 1
 311         fi
 312         if [ -n "$active" ]; then
 313                 rm -f "$lockf.lock"
 314                 echo >&2 "[$proj] gc already running on machine '$ahost' pid '$apid'"
 315                 exit 1
 316         fi
 317         printf "%s %s" "$$" "$hn" >"$lockf.lock"
 318         chmod 0664 "$lockf.lock"
 319         mv -f "$lockf.lock" "$lockf"
 320 }
 321
 322 # Create a repack subdirectory such that running repack in it will pack the
 323 # same things that a pack in the normal directory would except that the pack
 324 # is guaranteed to be generated in an optimized order by adding a suitable
 325 # synthesized ref in the refs/tags namespace (yes, pack-objects.c really does
 326 # behave differently depending on the contents of the refs/tags namespace).
 327 # Before calling this, pack-refs --all MUST be performed or the wrong pack
 328 # will end up being made.
 329 # If a ref deletion is pushed after making the repack subdir but before the
 330 # the actual repack, the discarded objects will be packed -- no big deal,
 331 # they'll get discarded the next time gc runs.
 332 # If a fast-forward ref update is pushed after making the repack subdir but
 333 # before the actual repack, it will be picked up and the new objects packed
 334 # (subject to the normal git repack race about picking such updates up).
 335 # If a non-fast-forward ref update is pushed after making the repack subdir but
 336 # before the actual repack, it will be picked up like a fast-forward update but
 337 # the discarded objects will be included like a ref deletion (until the next
 338 # scheduled gc takes place).
 339 make_repack_dir() {
 340         ! [ -d repack ] || rm -rf repack
 341         ! [ -d repack ] || { echo >&2 "[$proj] cannot remove repack subdirectory"; exit 1; }
 342         mkdir repack
 343         [ -d info ] || mkdir info
 344         ln -s ../config  repack/config
 345         ln -s ../info    repack/info
 346         ln -s ../objects repack/objects
 347         ln -s ../refs    repack/refs
 348         _lines=$(( $(LC_ALL=C wc -l <packed-refs) ))
 349         sed 's, refs/, refs/!/,' <packed-refs >repack/packed-refs
 350         optref="$(git rev-list -n 1 --all 2>/dev/null)" || :
 351         if [ -n "$optref" ]; then
 352                 echo "$optref refs/tags/!" >>repack/packed-refs
 353                 _lines=$(( $_lines + 1 ))
 354                 echo "$optref" >repack/HEAD
 355         else
 356                 cat HEAD >repack/HEAD
 357         fi
 358         if [ $(LC_ALL=C wc -l <repack/packed-refs) -ne "$_lines" ]; then
 359                 echo >&2 "[$proj] error: make_repack_dir failed packed-refs line count sanity check"
 360                 exit 1
 361         fi
 362 }
 363
 364 # Remove any crud that's been left behind by interrupted operations
 365 # that did not clean up after themselves
 366 remove_crud() {
 367         # Remove any existing FETCH_HEAD
 368         # There can only be a FETCH_HEAD if we've been fetching, not if we've been
 369         # receiving pushes (those never create a FETCH_HEAD).
 370         # And if we're fetching because we're a mirror, we know we're not fetching right
 371         # now since jobd.pl never runs a project's fetch simultaneously with its gc.
 372         # Therefore any existing FETCH_HEAD is junk.  And it may be many megabytes if
 373         # there were a lot of refs.
 374         rm -f FETCH_HEAD
 375
 376         # remove any existing pack_is_complete_test or repack subdirectories
 377         # If either exists when this function is called it's crud
 378         rm -rf pack_is_complete_test repack
 379
 380         # Remove any stale pack remnants that are more than an hour old.
 381         # Stale pack fragments are defined as any pack-<sha1>.ext where .ext is NOT
 382         # .pack AND the corresponding .pack DOES NOT exist.  A bunch of stale
 383         # pack-<sha1>.idx files without their corresponding .pack files are worthless
 384         # and just waste space.  Normally there shouldn't be any remnants but actually
 385         # this can happen when things are interrupted at just the wrong time.
 386         # Note that the objects/pack directory is created by git init and should
 387         # always exist.
 388         find objects/pack -maxdepth 1 -type f -mmin +60 -name "pack-$octet20.?*" -print |
 389         LC_ALL=C sed -e 's/^objects\/pack\/pack-//; s/\..*$//' | LC_ALL=C sort -u |
 390         while read packsha; do
 391                 ! [ -e "objects/pack/pack-$packsha.pack" ] || continue
 392                 rm -f "objects/pack/pack-$packsha".?*
 393         done
 394
 395         # Remove any stale tmp reflogs files that are more than one hour old.
 396         # Since they are created only while the pre-receive hook is running and
 397         # all it does is process a bunch of refs passed to it on standard input
 398         # it's inconceivable that it would ever take as much as an hour to run.
 399         if [ -d reflogs ]; then
 400                 find reflogs -maxdepth 1 -type f -mmin +60 -name "tmp_*" -exec rm -f '{}' + || :
 401         fi
 402
 403         # Remove any stale object tmp_obj_* files that are more than 3 hours old.
 404         # Really these files should only exist very briefly so there shouldn't be any
 405         # but things happen that can end up leaving them behind.
 406         find objects/$octet -maxdepth 1 -type f -mmin +180 -name "tmp_obj_?*" -exec rm -f '{}' + 2>/dev/null || :
 407
 408         # Remove any stale pack .keep files that are more than 12 hours old.
 409         # We don't do anything to create any permanent pack .keep files, so they must
 410         # be remnants from some failed push or something.  Removing the .keep will
 411         # allow the pack to be properly repacked.
 412         find objects/pack -maxdepth 1 -type f -mmin +720 -name "pack-$octet20.keep" -exec rm -f '{}' + || :
 413
 414         # Remove any stale tmp_pack_*, tmp_idx_*, tmp_bitmap_*, packtmp-* or .tmp-*-pack* files
 415         # that are more than 12 hours old.
 416         find objects/pack -maxdepth 1 -type f -mmin +720 \( \
 417                 -name "tmp_pack_?*" -o -name "tmp_idx_?*" -o -name "tmp_bitmap_?*" -o \
 418                 -name "packtmp-?*" -o -name ".tmp-?*-pack*" \
 419                 \) -exec rm -f '{}' + || :
 420
 421         # Remove any stale shallow_* files that are more than 12 hours old.
 422         # These can be left behind by Git >= 1.8.4.2 and < 2.0.0 when a client
 423         # requests a shallow clone.
 424         find . -maxdepth 1 -type f -mmin +720 -name "shallow_?*" -exec rm -f '{}' + || :
 425
 426         # Remove any stale *.temp files in the objects area that are more than 12 hours old.
 427         # This can be stale sha1.temp, or stale *.pack.temp so we kill all stale *.temp.
 428         find objects -type f -mmin +720 -name "*.temp" -exec rm -f '{}' + || :
 429
 430         # Remove any stale *.lock files in the htmlcache area that might have been left
 431         # behind after an abnormal exit during an attempt to update a cached file and
 432         # are more than 1 hour old.
 433         ! [ -d htmlcache ] || find htmlcache -type f -mmin +60 -name "*.lock" -exec rm -f '{}' + || :
 434
 435         # Remove any stale git-svn temp files that are more than 12 hours old.
 436         # The git-svn process creates temp files with random 10 character names
 437         # in the root of $GIT_DIR.  Unfortunately they do not have a recognizable
 438         # prefix, so we just have to kill any files with a 10-character name.  We
 439         # do this only for git-svn mirrors.  All characters are chosen from
 440         # [A-Za-z0-9_] so we can at least check that and fortunately the only
 441         # collision is 'FETCH_HEAD' but that shouldn't matter.
 442         # There may also be temp files with a Git_ prefix as well.
 443         if [ -n "$svn_mirror" ]; then
 444                 _randchar='[A-Za-z0-9_]'
 445                 _randchar2="$_randchar$_randchar"
 446                 _randchar4="$_randchar2$_randchar2"
 447                 _randchar10="$_randchar4$_randchar4$_randchar2"
 448                 find . -maxdepth 1 -type f -mmin +720 -name "$_randchar10" -exec rm -f '{}' + || :
 449                 find . -maxdepth 1 -type f -mmin +720 -name "Git_*" -exec rm -f '{}' + || :
 450         fi
 451
 452         # Remove any stale fast_import_crash_<pid> files that are more than 3 days old.
 453         if [ -n "$gfi_mirror" ]; then
 454                 find . -maxdepth 1 -type f -mmin +4320 -name "fast_import_crash_?*" -exec rm -f '{}' + || :
 455         fi
 456 }
 457
 458 #
 459 ## Garbage Collection Types
 460 ##
 461 ## There are two kinds of possible garbage collection (gc) operations:
 462 ##
 463 ## 1.  A normal, full gc
 464 ## 2.  A "mini" gc
 465 ##
 466 ## If the full garbage collection interval has expired (or gc has never been
 467 ## run), then a normal, full gc will take place.  Otherwise, a "mini" gc will
 468 ## take place if the file .needsgc exists.
 469 ##
 470 ## A "mini" gc is similar to "git gc --auto" in that it may not end up actually
 471 ## doing anything unless the right conditions are present so it's not a burden
 472 ## to run it often.  If the file .needsgc exists, a "mini" gc will occur at
 473 ## the next opportunity.
 474 ##
 475 ## Note, however, that the .nogc file suppresses ALL gc activity (normal or mini).
 476 #
 477
 478 proj="${1%.git}"
 479 shift
 480 cd "$cfg_reporoot/$proj.git"
 481 [ -d objects/pack ] || { rm -f gfi-packs; mkdir -p objects/pack; }
 482 mirror_url="$(get_mirror_url)"
 483 svn_mirror=
 484 ! is_svn_mirror_url "$mirror_url" || svn_mirror=1
 485 gfi_mirror=
 486 if [ -f gfi-packs ] && [ -s gfi-packs ] && is_gfi_mirror_url "$mirror_url"; then
 487         gfi_mirror=1
 488 fi
 489
 490 # If git config --bool --get girocco.redelta is explicitly false then automatic
 491 # redelta when there are less than $var_redelta_threshold objects will be suppressed.
 492 # On the other hand, if git config --get girocco.redelta is "always" then, on a full
 493 # gc only, for the final repack, deltas will always be recomputed.
 494 # This can be set on a per-project basis to avoid unusual pathological gc behavior.
 495 # Setting this will hurt efficiency of the affected repository.
 496 # Note that fast-import packs ALWAYS get new deltas regardless of this setting.
 497 noreusedeltaopt="--no-reuse-delta"
 498 [ "$(git config --bool --get girocco.redelta 2>/dev/null || :)" != "false" ] || noreusedeltaopt=
 499 alwaysredelta=
 500 [ "$(git config --get girocco.redelta 2>/dev/null || :)" != "always" ] || alwaysredelta=1
 501
 502 trap 'e=$?; rm -f .gc_in_progress; if [ $e != 0 ]; then echo "gc failed dir: $PWD" >&2; fi' EXIT
 503 trap 'exit 130' INT
 504 trap 'exit 143' TERM
 505
 506 # date -R is linux-only, POSIX equivalent is '+%a, %d %b %Y %T %z'
 507 datefmt='+%a, %d %b %Y %T %z'
 508
 509 isminigc=
 510 if check_interval lastgc $cfg_min_gc_interval; then
 511         if [ -e .needsgc ]; then
 512                 isminigc=1
 513         else
 514                 progress "= [$proj] garbage check skip (last at $(config_get lastgc))"
 515                 exit 0
 516         fi
 517 fi
 518 if [ -e .nogc ]; then
 519         progress "x [$proj] garbage check disabled"
 520         exit 0
 521 fi
 522
 523 if [ -n "$isminigc" ]; then
 524         # Perform a "mini" gc
 525         # Note that .delaygc is ignored here as that's only intended for full gc
 526         lock_gc
 527         rm -f .allowgc .needsgc
 528         remove_crud
 529         coalesce_reflogs
 530         prune_reflogs
 531         compact_reflogs
 532         miniactive=
 533         if [ -f .svnpack ] && [ -n "$svn_mirror" ]; then
 534                 miniactive=1
 535                 progress "+ [$proj] mini garbage check ($(date))"
 536                 make_svn_pack
 537         fi
 538         if [ -z "$cfg_delay_gfi_redelta" ] && [ -n "$gfi_mirror" ]; then
 539                 # $Girocco::Config::delay_gfi_redelta is false, force redeltification now
 540                 if [ -z "$miniactive" ]; then
 541                         miniactive=1
 542                         progress "+ [$proj] mini garbage check ($(date))"
 543                 fi
 544                 repack_gfi_packs
 545         fi
 546         # If there aren't at least 10 non-keep, non-bitmap, non-bndl packs then
 547         # don't actually process them yet
 548         lpo="--exclude-no-idx --exclude-keep --exclude-bitmap --exclude-bndl --quiet"
 549         packcnt="$(list_packs --count $lpo objects/pack)" || :
 550         if [ "${packcnt:-0}" -ge 10 ]; then
 551                 if [ -z "$miniactive" ]; then
 552                         miniactive=1
 553                         progress "+ [$proj] mini garbage check ($(date))"
 554                 fi
 555                 if [ -n "$gfi_mirror" ]; then
 556                         repack_gfi_packs
 557                         packcnt="$(list_packs --count $lpo objects/pack)" || :
 558                 fi
 559                 # if repack_gfi_packs dropped the pack count to < 10 don't combine
 560                 if [ "${packcnt:-0}" -ge 10 ]; then
 561                         combine_small_packs
 562                         packcnt="$(list_packs --count $lpo objects/pack)" || :
 563                 fi
 564                 # if we still have more than 10 packs trigger a full gc
 565                 if [ "${packcnt:-0}" -ge 10 ]; then
 566                         # We shouldn't be in a .delaygc state at this point, but if
 567                         # we are then nuke it because we really need a full gc now
 568                         rm -f .delaygc
 569                         git config --unset gitweb.lastgc
 570                         rm -f "$lockf"
 571                         progress "- [$proj] mini garbage check triggering full gc too many packs ($(date))"
 572                         exit 0
 573                 fi
 574         fi
 575         rm -f "$lockf"
 576         if [ -n "$miniactive" ]; then
 577                 git update-server-info
 578                 progress "- [$proj] mini garbage check ($(date))"
 579         else
 580                 progress "= [$proj] mini garbage check nothing but crud removal to do ($(date))"
 581         fi
 582         exit 0
 583 fi
 584
 585 # Avoid unnecessary garbage collections:
 586 #   1. If lastreceive is set and is older than lastgc
 587 #   -AND-
 588 #   2. We are not a fork (! -s alternates) -OR- lastparentgc is older than lastgc
 589
 590 # If lastgc is NOT set or lastreceive is NOT set we MUST run gc
 591 # If we are a fork and lastparentgc is NOT set we MUST run gc
 592
 593 # If the repo is dirty after removing any crud we MUST run gc
 594
 595 gcstart="$(date "$datefmt")"
 596 skipgc=
 597 isfork=
 598 ! [ -s objects/info/alternates ] || isfork=1
 599 lastparentgcsecs=
 600 [ -z "$isfork" ] || lastparentgcsecs="$(config_get_date_seconds lastparentgc)" || :
 601 lastreceivesecs=
 602 if lastreceivesecs="$(config_get_date_seconds lastreceive)" &&
 603    lastgcsecs="$(config_get_date_seconds lastgc)" &&
 604    [ $lastreceivesecs -lt $lastgcsecs ]; then
 605         # We've run gc since we last received, so maybe we can skip,
 606         # check if not fork or fork and lastparentgc < lastgc
 607         if [ -n "$isfork" ]; then
 608                 if [ -n "$lastparentgcsecs" ] &&
 609                    [ $lastparentgcsecs -lt $lastgcsecs ]; then
 610                         # We've run gc since our parent ran gc so we can skip
 611                         skipgc=1
 612                 fi
 613         else
 614                 # We don't have any alternates (we're not a forK) so we can skip
 615                 skipgc=1
 616         fi
 617 fi
 618
 619 # Prevent any other simultaneous gc operations
 620 lock_gc
 621
 622 # At this point, if .allowgc exists, it's now crud to be removed
 623 rm -f .allowgc
 624
 625 # Ideally we would do this in post-receive, but that would mean duplicating the
 626 # logic so it's available in the chroot jail and that's highly undesirable
 627 # Instead, since the first gc will be triggered immediately following the first
 628 # push, we do the check here as it's quick and harmless if HEAD is already valid
 629 check_and_set_head || :
 630
 631 # Always get rid of crud
 632 remove_crud
 633
 634 # Always perform reflogs maintenance
 635 coalesce_reflogs
 636 prune_reflogs
 637 compact_reflogs
 638
 639 # Run 'git svn gc' now for svn mirrors
 640 if [ -n "$svn_mirror" ]; then
 641         git svn gc || :
 642 fi
 643
 644 # Skip the actual gc if .delaygc is set
 645 if [ -e .delaygc ]; then
 646         progress "x [$proj] garbage check delayed (except for crud removal)"
 647         rm -f "$lockf"
 648         exit 0
 649 fi
 650
 651 # Do not skip gc if the repo is dirty
 652 if [ -n "$skipgc" ] && ! is_dirty; then
 653         progress "= [$proj] garbage check nothing but crud removal to do ($(date))"
 654         config_set lastgc "$gcstart"
 655         rm -f "$lockf"
 656         exit 0
 657 fi
 658
 659 bumptime=
 660 if [ -n "$isfork" ] && [ -z "$lastparentgcsecs" ]; then
 661         # set lastparentgc and then update gcstart to be at least 1 second later
 662         config_set lastparentgc "$gcstart"
 663         bumptime=1
 664 fi
 665 if [ -z "$lastreceivesecs" ]; then
 666         # set lastreceive and then update gcstart to be at least 1 second later
 667         config_set lastreceive "$gcstart"
 668         bumptime=1
 669 fi
 670 if [ -n "$bumptime" ]; then
 671         sleep 1
 672         gcstart="$(date "$datefmt")"
 673 fi
 674
 675 progress "+ [$proj] garbage check ($(date))"
 676
 677 newdeltas=
 678 [ -z "$alwaysredelta" ] || newdeltas=-f
 679 if [ -z "$newdeltas" ] && [ -n "$gfi_mirror" ]; then
 680         if [ $(list_packs --exclude-no-idx --count objects/pack) -le \
 681              $(list_packs --exclude-no-idx --count --quiet --only gfi-packs) ]; then
 682                 # Don't bother with repack_gfi_packs since everything's being repacked
 683                 newdeltas=-f
 684         fi
 685 fi
 686 if [ -z "$newdeltas" ] && [ -n "$noreusedeltaopt" ] &&
 687    [ $(list_packs --exclude-no-idx --count-objects objects/pack) -le $var_redelta_threshold ]; then
 688         # There aren't enough objects to worry about so just redelta to get the best pack
 689         newdeltas=-f
 690 fi
 691 if [ -z "$newdeltas" ]; then
 692         # Since we're not going to recompute deltas overall, we need to do the
 693         # "mini" maintenance so that we can get more optimal deltas
 694         [ -z "$noreusedeltaopt" ] || make_svn_pack
 695         repack_gfi_packs
 696         force_single_pack_redelta=
 697         [ -n "$gfi_mirror" ] || [ -n "$svn_mirror" ] || force_single_pack_redelta=1
 698         [ -z "$noreusedeltaopt" ] || combine_small_packs $force_single_pack_redelta
 699 fi
 700
 701 #
 702 ## Safe Pruning In Forks
 703 ##
 704 ## We are about to perform garbage collection.  We do NOT use the "git gc"
 705 ## command directly as it does not provide enough control over the fine details
 706 ## that we require.  However, we DO maintain a "gc.pid" file during our garbage
 707 ## collection so that a simultaneous "git gc" by an administrator will be
 708 ## blocked (and similarly we refuse to start garbage collection if we cannot
 709 ## create the "gc.pid" file).  When we say "gc" in the below description we are
 710 ## referring to our "gc.sh" script, NOT the "git gc" command.
 711 ##
 712 ## If the project we are running garbage collection (gc) on has any forks we
 713 ## must be careful not to remove any objects that while no longer referenced by
 714 ## this project (the parent) are still referenced by one or more forks (the
 715 ## children) otherwise the children will become corrupt and we can't abide
 716 ## corrupt children.
 717 ##
 718 ## One way to accomplish this is to simply hard-link all currently existing
 719 ## loose objects and packs in the parent into all the children that refer to the
 720 ## parent (via a line in their objects/info/alternates file) before beginning
 721 ## the gc operation and then relying on a subsequent gc in the child to clean up
 722 ## any excess objects/packs.  We used to use this strategy but it's very
 723 ## inefficient because:
 724 ##
 725 ##   1. The disk space used by the old pack(s)/object(s) will not be reclaimed
 726 ##      until all children (and their children, if any) run gc by which time
 727 ##      it's quite possible the topmost parent will have run gc again and
 728 ##      hard-linked yet another old pack down to its children (not to mention
 729 ##      loose objects).
 730 ##
 731 ##   2. As we are now using the "-A" option with "git repack", any new objects
 732 ##      in the parent that are not referenced by children will continually get
 733 ##      exploded out of the hard-linked pack in the children whenever the
 734 ##      children run gc.
 735 ##
 736 ##   3. To avoid suboptimal and/or unnecessarily many packs being hard-linked
 737 ##      into child forks, we must run the "mini" gc maintenance before we
 738 ##      perform the hard-linking into the children which provides yet another
 739 ##      source of inefficiency.
 740 ##
 741 ## Since we are using the "-A" option to "git repack" (that was not always the
 742 ## case) to guarantee we can access old ref values for long enough to send out
 743 ## a meaningful mail.sh notification, we now have another, more efficient,
 744 ## option available to prevent corruption of child forks that continue to refer
 745 ## to objects that are no longer reachable from any ref in the parent.
 746 ##
 747 ## The only things that need be copied (or hard-linked) into the child fork(s)
 748 ## are those objects that have become unreachable from any ref in the parent.
 749 ## They are the only things that could ever be removed by "git prune" and
 750 ## therefore the only things we need to prevent the loss of in order to avoid
 751 ## corruption of the child fork(s).
 752 ##
 753 ## Therefore we now use the following strategy instead to avoid excessive disk
 754 ## use and lots of unnecessary loose objects in child forks:
 755 ##
 756 ##   1. Run "git repack -A -d -l" in the parent BEFORE doing anything about
 757 ##      child forks.
 758 ##
 759 ##   2. Hard-link all remaining existing loose objects in the parent into the
 760 ##      immediate child forks.
 761 ##
 762 ##   3. Now run "git prune" in the parent.
 763 ##
 764 ## With this new strategy we avoid the need to run any "mini" gc maintenance
 765 ## before copying (or hard-linking) anything down to the child forks.
 766 ## Furthermore, only when the parent performs a non-fast-forward update will
 767 ## anything ever be transferred to the children leaving them unperturbed in the
 768 ## vast majority of cases.  Finally, even if the parent references objects the
 769 ## children do not, those objects will no longer continually end up in the
 770 ## children as unreachable loose objects after the children run gc.
 771 #
 772
 773 git pack-refs --all
 774 make_repack_dir
 775 touch .gc_in_progress
 776 rm -f .gc_failed bundles/*
 777 rm -f objects/pack/pack-*.bndl
 778 # We use the -A option with git repack so that unreachable objects can live
 779 # on for a time as loose objects.  This is particularly helpful if we just
 780 # happen to be in the process of sending out a ref update for a ref that was
 781 # force updated and the old ref value would have otherwise been removed by
 782 # repack because it was now unreachable.  Admittedly the window for gc to run
 783 # and do that before we manage to send out the ref update is not large, but
 784 # it would not be difficult to create such a situation.  Unfortunately, when
 785 # Git unpacks these unreachable objects it will give them the modification
 786 # time of the *.pack file they came out of.  This could be very, very old.
 787 # If that happens, the subsequent git prune --expire some_time_ago will still
 788 # remove the object(s) and our pending ref update will still lose out.
 789 # To prevent this from happening and to get the behavior we want, we now
 790 # touch the modification time of all pack-<sha>.pack files so that any
 791 # loosened objects get a current time.  Git does not provide any other
 792 # mechanism to do this.  We do not want to just touch all loose objects
 793 # left after the repack because that would cause objects that were loosened
 794 # previously to live on which we definitely do not want.
 795 list_packs --exclude-no-idx objects/pack | xargs touch -c 2>/dev/null || :
 796 # We wish to keep deltas from our last full pack so if we're not redeltaing
 797 # then make sure the .pack associated with the .bitmap has a newer mod time
 798 # (If there is no .bitmap then touch the pack with the most objects instead.)
 799 if [ -z "$newdeltas" ]; then
 800         bmpack="$(list_packs --exclude-no-bitmap --exclude-no-idx --max-matches 1 objects/pack)"
 801         [ -n "$bmpack" ] || bmpack="$(list_packs --exclude-no-idx --max-matches 1 --object-limit -1 --include-boundary objects/pack)"
 802         if [ -n "$bmpack" ] && [ -f "$bmpack" ] && [ -s "$bmpack" ]; then
 803                 sleep 1
 804                 touch -c "$bmpack" 2>/dev/null || :
 805         fi
 806 fi
 807 # The git repack command only supports bitmaps if all objects are being packed.
 808 # While it is theoretically possible that a project with a non-empty alternates
 809 # file ends up packing all objects (because it does not actually use any of the
 810 # objects found in the alternates), it's very unlikely.  And, in the unlikely
 811 # event that did occur, clients would see a message about only using one bitmap
 812 # because Git can only use one bitmap at a time and at least one of the
 813 # alternates is bound to have a bitmap.  Therefore if we see a non-empty
 814 # alternates file, we disable writing bitmaps which avoids the warning and any
 815 # possibility of a client warning as well.
 816 nobm=
 817 [ -z "$var_have_git_172" ] || ! [ -s objects/info/alternates ] ||
 818         nobm='-c repack.writebitmaps=false -c pack.writebitmaps=false'
 819 progress "~ [$proj] running full gc repack${nobm:+ (bitmaps disabled)}"
 820 cd repack
 821 # We run git repack from the repack subdirectory so we can force optimized packs
 822 # to be generated even for repositories that do not have any tagged commits
 823 git $nobm repack $packopts -A -d -l $quiet $newdeltas $@
 824 cd ..
 825 rm -rf repack
 826 ! [ -e .gc_failed ] || exit 1
 827 # These, if they exist, are now meaningless and need to be removed
 828 rm -f gfi-packs .needsgc .svnpack .svnpackgc
 829 allpacks="$(echo objects/pack/pack-$octet20.pack)"
 830 curhead="$(cat HEAD)"
 831 pkrf=
 832 ! [ -e packed-refs ] || pkrf=packed-refs
 833 eval "reposizek=$(( $(echo 0 $(du -k $pkrf $allpacks 2>/dev/null | LC_ALL=C awk '{print $1}') |
 834         LC_ALL=C sed -e 's/ / + /g') ))"
 835 git update-server-info
 836 # The -A option to `git repack` may have caused some loose objects to pop
 837 # out of their packs.  We must make these objects group writable so that they
 838 # can be freshened by other pushers.  Technically we need only do this for
 839 # push projects but to enable mirror projects to be more easily converted to
 840 # push projects, we go ahead and do it for all projects.
 841 { find objects/$octet -type f -name "$octet19" -exec chmod ug+w '{}' + || :; } 2>/dev/null
 842
 843 if has_forks "$proj"; then
 844         progress "~ [$proj] hard-linking loose objects into immediate child forks"
 845         # We have to update the lastparentgc time in the child forks even if they do not get any
 846         # new "loose objects" because they need to run gc just in case the parent now has some
 847         # objects that used to only be in the child so they can be removed from the child.
 848         # For example, a "patch" might be developed first in a fork and then later accepted into
 849         # the parent in which case the objects making up the patch in the child fork are now
 850         # redundant (since they're now in the parent as well) and need to be removed from the
 851         # child fork which can only happen if the child fork runs gc.
 852         forkdir="$proj"
 853         # It is enough to copy objects just one level down and get_repo_list
 854         # takes a regular expression (which is automatically prefixed with '^')
 855         # so we can easily match forks exactly one level down from this project
 856         get_repo_list "$forkdir/[^/]*:" |
 857                 while read fork; do
 858                         # Ignore forks that do not exist or are symbolic links
 859                         ! [ -L "$cfg_reporoot/$fork.git" ] && [ -d "$cfg_reporoot/$fork.git" ] ||
 860                                 continue
 861                         # Or do not have a non-zero length alternates file
 862                         [ -s "$cfg_reporoot/$fork.git/objects/info/alternates" ] ||
 863                                 continue
 864                         # Match objects in parent project
 865                         for d in objects/$octet; do
 866                                 [ "$d" != "objects/$octet" ] || continue
 867                                 mkdir -p "$cfg_reporoot/$fork.git/$d"
 868                                 find "$d" -maxdepth 1 -type f -name "$octet19" -exec \
 869                                         "$var_sh_bin" -c 'ln -f "$@" '"'$cfg_reporoot/$fork.git/$d/'" sh '{}' + || :
 870                         done
 871                         # Update the fork's lastparentgc date (must be current, not $gcstart)
 872                         git --git-dir="$cfg_reporoot/$fork.git" config \
 873                                 gitweb.lastparentgc "$(date "$datefmt")"
 874                 done
 875 fi
 876
 877 # The git prune command does not take a -q or --quiet but started outputting
 878 # 'Checking connectivity' progress messages in v1.7.9.  However, we can
 879 # suppress those by piping through cat as it only activates the progress
 880 # messages when stderr is a tty.  We only expire loose objects older than one
 881 # day just in case there's some pending action (such as sending out a ref
 882 # update) in progress that might want to examine them.  This may leave us with
 883 # loose objects.  That's okay because at the next gc interval, we will always
 884 # run gc if we see any loose objects regardless of whether or not we've seen
 885 # any updates or we've received new linked objects from our parent.  Note that
 886 # in order to keep loose objects that just recently became unreferenced but
 887 # have a very old modification date around we rely on some help from both the
 888 # update.sh and hooks/pre-receive scripts.  Furthermore, since Git v2.2.0
 889 # (d3038d22 prune: keep objects reachable from recent objects) an unreachable
 890 # object that would otherwise be pruned (because it's too old) will be kept
 891 # alive by an unreachable object that refers to it that's not old enough to
 892 # be pruned yet.
 893 prunecmd='git prune --expire 1_day_ago'
 894 [ -n "$show_progress" ] ||
 895 prunecmd="{ $prunecmd 2>&1 || touch .gc_failed; } | cat"
 896 progress "~ [$proj] pruning expired unreachable loose objects"
 897 eval "$prunecmd"
 898 ! [ -e .gc_failed ] || exit 1
 899
 900 # darcs:// mirrors have a xxx.log file that will grow endlessly
 901 # if this is a mirror and the file exists, shorten it to 10000 lines
 902 # also take this opportunity to optimize the darcs repo
 903 if ! [ -e .nofetch ] && [ -n "$cfg_mirror" ]; then
 904         url="$(config_get baseurl)" || :
 905         case "$url" in darcs://*)
 906                 if [ -n "$cfg_mirror_darcs" ]; then
 907                         url="${url%/}"
 908                         basedarcs="$(basename "${url#darcs:/}")"
 909                         if [ -f "$basedarcs.log" ]; then
 910                                 tail -n 10000 "$basedarcs.log" >"$basedarcs.log.$$"
 911                                 mv -f "$basedarcs.log.$$" "$basedarcs.log"
 912                         fi
 913                         if [ -d "$basedarcs.darcs" ]; then
 914                                 (
 915                                         cd "$basedarcs.darcs"
 916                                         # without show_progress suppress non-error output
 917                                         [ -n "$show_progress" ] || exec >/dev/null
 918                                         # Note that this does not optimize _darcs/inventories/ :(
 919                                         darcs optimize || :
 920                                 )
 921                         fi
 922                 fi
 923         esac
 924 fi
 925
 926 # Create a matching .bndl header file for the all-in-one pack we just created
 927 # but only if we're not a fork (otherwise the bundle would not be complete)
 928 # and we are running at least Git version 1.7.2 (pack_is_complete always fails otherwise)
 929 if ! [ -s objects/info/alternates ] && [ -n "$var_have_git_172" ]; then
 930         # There should only be one pack in $allpacks but if there was a
 931         # simultaneous push...
 932         # The one we just created will have a .idx and will NOT have a .keep
 933         progress "~ [$proj] creating downloadble bundle header"
 934         pkfound=
 935         pkhead=
 936         for pk in $allpacks; do
 937                 [ -s "$pk" ] || continue
 938                 pkbase="${pk%.pack}"
 939                 [ -s "$pkbase.idx" ] || continue
 940                 ! [ -e "$pkbase.keep" ] || continue
 941                 if pkhead="$(pack_is_complete "$PWD/$pk" "$PWD/packed-refs" "$curhead")"; then
 942                         pkfound="$pkbase"
 943                         break;
 944                 fi
 945         done
 946         if [ -n "$pkfound" ] && [ -n "$pkhead" ]; then
 947                 {
 948                         symref=
 949                         case "$curhead" in "ref: refs/"?*|"ref:refs/"?*|"refs/"?*)
 950                                 symref="${curhead#ref:}"
 951                                 symref="${symref# }"
 952                         esac
 953                         bndlurl=
 954                         [ -z "$cfg_httpbundleurl" ] || bndlurl=" url=$cfg_httpbundleurl/$proj.git/clone.bundle"
 955                         echo "# v2 git bundle"
 956                         LC_ALL=C sed -ne "/^$octet20 refs\/[^ $tab]*\$/ p" <packed-refs
 957                         if [ -n "$symref" ]; then
 958                                 printf "$pkhead HEAD\0symref=HEAD:%s%s\n" "$symref" "$bndlurl"
 959                         else
 960                                 echo "$pkhead HEAD"
 961                         fi
 962                         echo ""
 963                 } >"$pkbase.bndl"
 964                 bndletag="$("$cfg_basedir/bin/rangecgi" --etag -m 1 "$pkbase.bndl" "$pkbase.pack")" || :
 965                 bndlsha="$(printf '%s' "$bndletag" | git hash-object --stdin)" || :
 966                 if [ -n "$bndletag" ]; then
 967                         case "$bndlsha" in $octet20)
 968                                 bndlshatrailer="${bndlsha#????????}"
 969                                 bndlshaprefix="${bndlsha%$bndlshatrailer}"
 970                                 bndlname="$(TZ=UTC date +%Y%m%d_%H%M%S)-${bndlshaprefix:-0}"
 971                                 [ -d bundles ] || mkdir bundles
 972                                 echo "${pkbase#objects/pack/}.bndl" >"bundles/$bndlname"
 973                                 echo "${pkbase#objects/pack/}.pack" >>"bundles/$bndlname"
 974                                 ln -s -f -n "$bndlname" bundles/latest
 975                         esac
 976                 fi
 977         fi
 978 fi
 979
 980 # Record the size of this repo as the sum of its *.pack sizes as 1024-byte blocks
 981 config_set_raw girocco.reposizek "${reposizek:-0}"
 982
 983 # We use $gcstart here to avoid a race where a push occurs during the gc itself
 984 # and the next future gc could be incorrectly skipped if we used the current
 985 # timestamp here instead
 986 config_set lastgc "$gcstart"
 987 rm -f "$lockf"
 988
 989 progress "- [$proj] garbage check ($(date))"