jobd/update.sh

   1 #!/bin/sh
   2
   3 . @basedir@/shlib.sh
   4
   5 set -e
   6
   7 if [ $# -ne 1 ]; then
   8         echo "Usage: update.sh projname" >&2
   9         exit 1
  10 fi
  11
  12 # date -R is linux-only, POSIX equivalent is '+%a, %d %b %Y %T %z'
  13 datefmt='+%a, %d %b %Y %T %z'
  14
  15 git_fetch_q_progress() {
  16         PATH="$var_git_exec_path:$cfg_basedir/bin:$PATH" @basedir@/jobd/git-fetch-q-progress.sh "$@"
  17 }
  18
  19 # freshen_loose_objects full-sha ...
  20 # if "$n" is a loose object, set its modification time to now
  21 # otherwise silently do nothing with no error.  To facilitate conversion
  22 # of mirror projects to push projects we also add group write  permission.
  23 freshen_loose_objects() {
  24         _list=
  25         for _sha; do
  26                 _fn="${_sha#??}"
  27                 _shard="${_sha%$_fn}"
  28                 _list="$_list objects/$_shard/$_fn"
  29         done
  30         if [ -n "$_list" ]; then
  31                 chmod ug+w $_list 2>/dev/null || :
  32                 touch -c $_list 2>/dev/null || :
  33         fi
  34 }
  35
  36 # darcs fast-export | git fast-import with error handling
  37 git_darcs_fetch() (
  38         set_utf8_locale
  39         _err1=
  40         _err2=
  41         exec 3>&1
  42         { read -r _err1 || :; read -r _err2 || :; } <<-EOT
  43         $(
  44                 exec 4>&3 3>&1 1>&4 4>&-
  45                 {
  46                         _e1=0
  47                         "$cfg_basedir"/bin/darcs-fast-export \
  48                                 --export-marks="$(pwd)/dfe-marks" \
  49                                 --import-marks="$(pwd)/dfe-marks" "$1" 3>&- || _e1=$?
  50                         echo $_e1 >&3
  51                 } |
  52                 {
  53                         _e2=0
  54                         git fast-import \
  55                                 --export-marks="$(pwd)/gfi-marks" \
  56                                 --export-pack-edges="$(pwd)/gfi-packs" \
  57                                 --import-marks="$(pwd)/gfi-marks" \
  58                                 --force 3>&- || _e2=$?
  59                         echo $_e2 >&3
  60                 }
  61         )
  62         EOT
  63         exec 3>&-
  64         [ "$_err1" = 0 ] && [ "$_err2" = 0 ]
  65         return $?
  66 )
  67
  68 # bzr fast-export | git fast-import with error handling
  69 git_bzr_fetch() (
  70         set_utf8_locale
  71         BZR_LOG=/dev/null
  72         export BZR_LOG
  73         _err1=
  74         _err2=
  75         exec 3>&1
  76         { read -r _err1 || :; read -r _err2 || :; } <<-EOT
  77         $(
  78                 exec 4>&3 3>&1 1>&4 4>&-
  79                 {
  80                         _e1=0
  81                         bzr fast-export --plain \
  82                                 --export-marks="$(pwd)/bfe-marks" \
  83                                 --import-marks="$(pwd)/bfe-marks" "$1" 3>&- || _e1=$?
  84                         echo $_e1 >&3
  85                 } |
  86                 {
  87                         _e2=0
  88                         git fast-import \
  89                                 --export-marks="$(pwd)/gfi-marks" \
  90                                 --export-pack-edges="$(pwd)/gfi-packs" \
  91                                 --import-marks="$(pwd)/gfi-marks" \
  92                                 --force 3>&- || _e2=$?
  93                         echo $_e2 >&3
  94                 }
  95         )
  96         EOT
  97         exec 3>&-
  98         [ "$_err1" = 0 ] && [ "$_err2" = 0 ]
  99         return $?
 100 )
 101
 102 [ -n "$cfg_mirror" ] || { echo "Mirroring is disabled" >&2; exit 0; }
 103
 104 umask 002
 105 [ "$cfg_permission_control" != "Hooks" ] || umask 000
 106 clean_git_env
 107
 108 proj="${1%.git}"
 109 cd "$cfg_reporoot/$proj.git"
 110
 111 # Activate a mini-gc if needed
 112 # We do this here as well as after a successful fetch so that if we're stuck
 113 # in a fetch loop where fetches are succeeding in fetching new packs but the
 114 # ref update is failing for some reason (perhaps a non-commit under refs/heads)
 115 # and a previous invokation therefore had a "bang" exit then we will still
 116 # get the .needsgc flag set in a timely fashion to avoid excess pack build up.
 117 check_and_set_needsgc
 118
 119 trap 'if [ $? != 0 ]; then echo "update failed dir: $PWD" >&2; fi; rm -f "$bang_log"' EXIT
 120 trap 'exit 130' INT
 121 trap 'exit 143' TERM
 122
 123 if [ "${force_update:-0}" = "0" ] && check_interval lastrefresh $cfg_min_mirror_interval; then
 124         progress "= [$proj] update skip (last at $(config_get lastrefresh))"
 125         exit 0
 126 fi
 127 if [ -e .nofetch ]; then
 128         progress "x [$proj] update disabled (.nofetch exists)"
 129         exit 0
 130 fi
 131 progress "+ [$proj] update ($(date))"
 132
 133 # Any pre-existing FETCH_HEAD from a previous fetch, failed or not, is garbage
 134 rm -f FETCH_HEAD
 135
 136 # A previous failed update attempt can leave a huge tmp_pack_XXXXXX file behind.
 137 # Since no pushes are allowed to mirrors, we know that any such files that exist
 138 # at this point in time are garbage and can be safely deleted, we do not even
 139 # need to check how old they are.  A tmp_idx_XXXXXX file is also created during
 140 # the later stages of the fetch process, so we kill any of those as well.
 141 find -L objects/pack -maxdepth 1 -type f -name "tmp_pack_?*" -exec rm -f '{}' + || :
 142 find -L objects/pack -maxdepth 1 -type f -name "tmp_idx_?*" -exec rm -f '{}' + || :
 143
 144 # Make sure we have a reflogs subdirectory and abort the update if not
 145 # This should not count as a normal "bang" failure if unsuccessful
 146 [ -d reflogs ] || mkdir -p reflogs >/dev/null 2>&1 || :
 147 [ -d reflogs ]
 148
 149 bang_setup
 150 bang_action="update"
 151 bang_trap() {
 152         if [ -n "$1" ]; then
 153                 # Throttle retries
 154                 # Since gitweb shows the .last_refresh date, it's safe to update
 155                 # gitweb.lastrefresh to throttle the updates w/o corrupting the
 156                 # last refresh date display on the gitweb summary page
 157                 # It's therefore important that we do NOT touch .last_refresh here
 158                 config_set lastrefresh "$(date "$datefmt")"
 159         fi
 160 }
 161
 162 bang echo "Project: $proj"
 163 bang echo "   Date: $(TZ=UTC date '+%Y-%m-%d %T UTC')"
 164 bang echo ""
 165 mail="$(config_get owner)" || :
 166 url="$(config_get baseurl)" || :
 167 case "$url" in *"       "*|*" "*|"")
 168         bang_eval 'echo "Bad mirror URL (\"$url\")"; ! :'
 169         exit 1
 170 esac
 171 bang echo "Mirroring from URL \"$url\""
 172 bang echo ""
 173 statusok="$(git config --bool gitweb.statusupdates 2>/dev/null || echo true)"
 174 mailaddrs=
 175 [ "$statusok" = "false" ] || [ -z "$mail" ] || mailaddrs="$mail"
 176 [ -z "$cfg_admincc" ] || [ "$cfg_admincc" = "0" ] || [ -z "$cfg_admin" ] ||
 177 if [ -z "$mailaddrs" ]; then mailaddrs="$cfg_admin"; else mailaddrs="$mailaddrs,$cfg_admin"; fi
 178
 179 bang_eval "git for-each-ref --format '%(refname) %(objectname)' >.refs-temp"
 180 bang_eval "LC_ALL=C sort -b -k1,1 <.refs-temp >.refs-before"
 181 ! [ -e .delaygc ] || >.allowgc || :
 182 svnpackcreated=
 183
 184 # Make sure we don't get any unwanted loose objects
 185 # Starting with Git v2.10.0 fast-import can generate loose objects unless we
 186 # tweak its configuration to prevent that
 187 git_add_config 'fetch.unpackLimit=1'
 188 # Note the git config documentation is wrong
 189 # transfer.unpackLimit, if set, overrides fetch.unpackLimit
 190 git_add_config 'transfer.unpackLimit=1'
 191 # But not the Git v2.10.0 and later fastimport.unpackLimit which improperly uses <= instead of <
 192 git_add_config 'fastimport.unpackLimit=0'
 193
 194 case "$url" in
 195         svn://* | svn+http://* | svn+https://* | svn+file://* | svn+ssh://*)
 196                 [ -n "$cfg_mirror_svn" ] || { echo "Mirroring svn is disabled" >&2; exit 0; }
 197                 # Use an 'anonsvn' username as is commonly used for anonymous svn
 198                 # Use an 'anonsvn' password as is commonly used for anonymous svn
 199                 GIT_ASKPASS_PASSWORD=anonsvn
 200                 export GIT_ASKPASS_PASSWORD
 201                 # Update the git svn url to match baseurl but be cognizant of any
 202                 # needed prefix changes.  See the comments in taskd/clone.sh about
 203                 # why we need to put up with a prefix in the first place.
 204                 case "$url" in svn+ssh://*) svnurl="$url";; *) svnurl="${url#svn+}";; esac
 205                 svnurl="${svnurl%/}"
 206                 svnurlold="$(config_get svnurl)" || :
 207                 if [ "$svnurl" != "$svnurlold" ]; then
 208                         # We better already have an svn-remote.svn.fetch setting
 209                         bang test -n "$(git config --get-all svn-remote.svn.fetch)" || :
 210                         # the only way to truly know what the proper prefix is
 211                         # is to attempt a fresh git-svn init -s on the new url
 212                         rm -rf svn-new-url || :
 213                         # We require svn info to succeed on the URL otherwise it's
 214                         # simply not a valid URL and without using -s on the init it
 215                         # will not otherwise be tested until the fetch
 216                         bang eval 'svn --non-interactive --username anonsvn --password anonsvn info "$svnurl" >/dev/null'
 217                         bang mkdir svn-new-url
 218                         GIT_DIR=svn-new-url bang git init --bare --quiet
 219                         # We initially use -s for the init which will possibly shorten
 220                         # the URL.  However, the shortening can fail if a password is
 221                         # not required for the longer version but is for the shorter,
 222                         # so try again without -s if the -s version fails.
 223                         cmdstr='git svn init --username=anonsvn --prefix "" -s "$svnurl" </dev/null >/dev/null 2>&1 || '
 224                         cmdstr="$cmdstr"'git svn init --username=anonsvn --prefix "" "$svnurl" </dev/null >/dev/null 2>&1'
 225                         GIT_DIR=svn-new-url bang eval "$cmdstr"
 226                         gitsvnurl="$(GIT_DIR=svn-new-url git config --get svn-remote.svn.url)" || :
 227                         gitsvnfetch="$(GIT_DIR=svn-new-url git config --get svn-remote.svn.fetch)" || :
 228                         gitsvnprefixnew="${gitsvnfetch%%:*}"
 229                         gitsvnsuffixnew="${gitsvnprefixnew##*/}"
 230                         gitsvnprefixnew="${gitsvnprefixnew%$gitsvnsuffixnew}"
 231                         rm -rf svn-new-url || :
 232                         # Using GIT_DIR= with bang leaves it set to svn-new-url, so reset it to .
 233                         GIT_DIR=.
 234                         if [ "$gitsvnurl" != "$(git config --get svn-remote.svn.url || :)" ]; then
 235                                 # The url has been changed.
 236                                 # We must update the url and replace the prefix on all config items
 237                                 gitsvnfetch="$(git config --get-all svn-remote.svn.fetch | head -1)" || :
 238                                 gitsvnprefixold="${gitsvnfetch%%:*}"
 239                                 gitsvnsuffixold="${gitsvnprefixold##*/}"
 240                                 gitsvnprefixold="${gitsvnprefixold%$gitsvnsuffixold}"
 241                                 git config --remove-section 'svn-remote.svnnew' 2>/dev/null || :
 242                                 git config 'svn-remote.svnnew.url' "$gitsvnurl"
 243                                 git config --get-regexp '^svn-remote\.svn\.' |
 244                                 while read -r sname sval; do
 245                                         case "$sname" in
 246                                         svn-remote.svn.fetch|svn-remote.svn.branches|svn-remote.svn.tags)
 247                                                 sname="${sname#svn-remote.svn.}"
 248                                                 sval="${sval#$gitsvnprefixold}"
 249                                                 bang git config --add "svn-remote.svnnew.$sname" "${gitsvnprefixnew}$sval"
 250                                         esac
 251                                 done
 252                                 test $? -eq 0
 253                                 bang git config -f svn/.metadata svn-remote.svn.reposRoot "$gitsvnurl"
 254                                 bang git config --remove-section svn-remote.svn
 255                                 bang git config --rename-section svn-remote.svnnew svn-remote.svn
 256                         fi
 257                         bang config_set svnurl "$svnurl"
 258                 fi
 259                 # remove any stale *.lock files greater than 1 hour old in case
 260                 # git-svn was killed on the last update because it took too long
 261                 find -L svn -type f -name '*.lock' -mmin +60 -exec rm -f '{}' + 2>/dev/null || :
 262                 # remember the starting time so we can easily combine fetched loose objects
 263                 # we sleep for 1 second after creating .svnpack to make sure all objects are newer
 264                 if ! [ -e .svnpack ]; then
 265                         svnpackcreated=1
 266                         rm -f .svnpack
 267                         >.svnpack
 268                         sleep 1
 269                 fi
 270                 GIT_DIR=. bang git svn fetch --log-window-size=$var_log_window_size --username=anonsvn --quiet </dev/null
 271                 # git svn does not preserve group permissions in the svn subdirectory
 272                 chmod -R ug+rw,o+r svn
 273                 # git svn also leaves behind ref turds that end with @nnn
 274                 # We get rid of them now
 275                 git for-each-ref --format='%(refname)' |
 276                 LC_ALL=C sed '/^..*@[1-9][0-9]*$/!d; s/^/delete /' |
 277                 git_updateref_stdin
 278                 unset GIT_ASKPASS_PASSWORD
 279                 ;;
 280         darcs://*)
 281                 [ -n "$cfg_mirror_darcs" ] || { echo "Mirroring darcs is disabled" >&2; exit 0; }
 282                 httpurl="http://${url#darcs://}"
 283                 # remove any stale lock files greater than 1 hour old in case
 284                 # darcs_fast_export was killed on the last update because it took too long
 285                 find -L *.darcs -maxdepth 2 -type f -name 'lock' -mmin +60 -exec rm -f '{}' + 2>/dev/null || :
 286                 bang git_darcs_fetch "$httpurl"
 287                 ;;
 288         bzr://*)
 289                 [ -n "$cfg_mirror_bzr" ] || { echo "Mirroring bzr is disabled" >&2; exit 0; }
 290                 bzrurl="${url#bzr://}"
 291                 bang git_bzr_fetch "$bzrurl"
 292                 ;;
 293         hg+http://* | hg+https://* | hg+file://* | hg+ssh://*)
 294                 [ -n "$cfg_mirror_hg" ] || { echo "Mirroring hg is disabled" >&2; exit 0; }
 295                 # We just remove hg+ here, so hg+http://... becomes http://...
 296                 hgurl="${url#hg+}"
 297                 # Fetch any new updates
 298                 bang hg -R "$(pwd)/repo.hg" pull
 299                 # Do the fast-export | fast-import
 300                 bang git_hg_fetch
 301                 ;;
 302         *)
 303                 [ "$url" = "$(git config --get remote.origin.url || :)" ] || bang config_set_raw remote.origin.url "$url"
 304                 pruneopt=--prune
 305                 [ "$(git config --bool fetch.prune 2>/dev/null || :)" != "false" ] || pruneopt=
 306                 if ! is_gfi_mirror_url "$url"; then
 307                         lastwasclean=
 308                         [ "$(git config --bool girocco.lastupdateclean 2>/dev/null || :)" != "true" ] || lastwasclean=1
 309                         nextisclean=
 310                         [ "$(git config --bool girocco.cleanmirror 2>/dev/null || :)" != "true" ] || nextisclean=1
 311                         if [ "$nextisclean" != "$lastwasclean" ]; then
 312                                 if [ -n "$nextisclean" ]; then
 313                                         git config --replace-all remote.origin.fetch "+refs/heads/*:refs/heads/*"
 314                                         git config --add remote.origin.fetch "+refs/tags/*:refs/tags/*"
 315                                         git config --add remote.origin.fetch "+refs/notes/*:refs/notes/*"
 316                                         git config --add remote.origin.fetch "+refs/top-bases/*:refs/top-bases/*"
 317                                 else
 318                                         git config --replace-all remote.origin.fetch "+refs/*:refs/*"
 319                                 fi
 320                         fi
 321                 fi
 322                 # remember the starting time so we can easily detect new packs for fast-import mirrors
 323                 # we sleep for 1 second after creating .gfipack to make sure all packs are newer
 324                 if is_gfi_mirror_url "$url" && [ ! -e .gfipack ]; then
 325                         rm -f .gfipack
 326                         >.gfipack
 327                         sleep 1
 328                 fi
 329                 fetcharg="default"
 330                 git config remotes.default >/dev/null 2>&1 || fetcharg="--all"
 331                 fetchcmd="git fetch"
 332                 if [ -n "$var_have_git_171" ] && [ "${show_progress:-0}" != "0" ]; then
 333                         # git fetch learned --progress in v1.7.1
 334                         case "$show_progress" in
 335                         [2-9]*|1[0-9]*)
 336                                 # full volume progress with all the spammy noise
 337                                 fetchcmd="$fetchcmd --progress"
 338                                 ;;
 339                         *)
 340                                 # a kinder, gentler progress that doesn't leave one
 341                                 # covered all over in exploded bits of spam afterwards
 342                                 fetchcmd="git_fetch_q_progress"
 343                                 ;;
 344                         esac
 345                 fi
 346                 GIT_SSL_NO_VERIFY=1 bang_eval "$fetchcmd" $pruneopt --multiple "$fetcharg"
 347                 if ! is_gfi_mirror_url "$url" && [ "$nextisclean" != "$lastwasclean" ]; then
 348                         if [ -n "$nextisclean" ]; then
 349                                 # We must manually purge the unclean refs now as even prune won't do it
 350                                 git for-each-ref --format='%(refname)' |
 351                                 LC_ALL=C sed \
 352                                         -e '/^refs\/heads\//d' \
 353                                         -e '/^refs\/tags\//d' \
 354                                         -e '/^refs\/notes\//d' \
 355                                         -e '/^refs\/top-bases\//d' \
 356                                         -e 's/^/delete /' |
 357                                 git_updateref_stdin
 358                         fi
 359                         git config --bool girocco.lastupdateclean ${nextisclean:-0}
 360                 fi
 361                 if [ -e .gfipack ] && is_gfi_mirror_url "$url"; then
 362                         find -L objects/pack -type f -newer .gfipack -name "pack-$octet20*.pack" -print >>gfi-packs
 363                         rm -f .gfipack
 364                 fi
 365                 ;;
 366 esac
 367
 368 # The objects subdirectories permissions must be updated now.
 369 # In the case of a dumb http clone, the permissions will not be correct
 370 # (missing group write) despite the core.sharedrepository=1 setting!
 371 # The objects themselves seem to have the correct permissions.
 372 # This problem appears to have been fixed in the most recent git versions.
 373 perms=g+w
 374 [ "$cfg_permission_control" != "Hooks" ] || perms=go+w
 375 chmod $perms $(find -L objects -maxdepth 1 -type d) 2>/dev/null || :
 376
 377 bang git update-server-info
 378
 379 # We maintain the last refresh date in two places deliberately
 380 # so that it's available as part of the config data and also
 381 # as a standalone file timestamp that can be accessed without git.
 382 bang config_set lastrefresh "$(date "$datefmt")"
 383 { >.last_refresh; } 2>/dev/null || :
 384
 385 # Check to see if any refs changed
 386 bang_eval "git for-each-ref --format '%(refname) %(objectname)' >.refs-temp"
 387 bang_eval "LC_ALL=C sort -b -k1,1 <.refs-temp >.refs-after"
 388 refschanged=
 389 cmp -s .refs-before .refs-after || refschanged=1
 390
 391 # There's no way to get git svn to fetch packs, so we always need to run
 392 # a mini-gc afterwards if svn actually fetched anything, but that's okay
 393 # because it will be very quick
 394 if [ -z "$refschanged" ] && [ -n "$svnpackcreated" ]; then
 395         # we created the .svnpack but didn't actually fetch anything
 396         # so remove it to avoid forcing a mini-gc if not necessary
 397         rm -f .svnpack
 398 fi
 399 if [ -e .svnpack ] && ! [ -e .needsgc ]; then
 400         >.needsgc
 401 fi
 402
 403 # Force a mini-gc if $Girocco::Config::delay_gfi_redelta is false and there's
 404 # at least one gfi pack present now
 405 if [ -z "$cfg_delay_gfi_redelta" ] && ! [ -e .needsgc ] &&
 406    [ -f gfi-packs ] && [ -s gfi-packs ] && is_gfi_mirror_url "$url"; then
 407         >.needsgc
 408 fi
 409
 410 # Activate a mini-gc if needed
 411 check_and_set_needsgc
 412
 413 # Look at which refs changed and trigger ref-change for these
 414 sockpath="$cfg_chroot/etc/taskd.socket"
 415 if [ -n "$refschanged" ]; then
 416         bang config_set lastreceive "$(date '+%a, %d %b %Y %T %z')"
 417         # We always use UTC for the log timestamp so that chroot and non-chroot match up.
 418         # We don't have to worry about multiple log files since only one update runs
 419         lognamets="$(TZ=UTC date '+%Y%m%d_%H%M%S')"
 420         loghhmmss="${lognamets##*_}"
 421         logname="reflogs/${lognamets%%_*}"
 422         # We freshen the mod time to now on any old or new ref that is a loose object
 423         # For old refs we do it so we will be able to keep them around for 1 day
 424         # For new refs we do it in case we are about to run gc and the new ref
 425         # actually points to an oldish loose object that had been unreachable
 426         # We probably do not need to do it for new refs as Git tries to do that,
 427         # but since we're already doing it for old refs (which Git does not do),
 428         # it's almost no extra work for new refs, just in case.
 429         {
 430                 echo "ref-changes %$proj% $proj"
 431                 LC_ALL=C join .refs-before .refs-after |
 432                 LC_ALL=C sed -e '/^[^ ][^ ]* \([^ ][^ ]*\) \1$/d' |
 433                         while read ref old new; do
 434                                 echo "$loghhmmss $old $new $ref" >&3
 435                                 freshen_loose_objects "$old" "$new"
 436                                 echo "$old $new $ref"
 437                         done
 438                 LC_ALL=C join -v 1 .refs-before .refs-after |
 439                         while read ref old; do
 440                                 echo "$loghhmmss $old 0000000000000000000000000000000000000000 $ref" >&3
 441                                 freshen_loose_objects "$old"
 442                                 echo "$old 0000000000000000000000000000000000000000 $ref"
 443                         done
 444                 LC_ALL=C join -v 2 .refs-before .refs-after |
 445                         while read ref new; do
 446                                 echo "$loghhmmss 0000000000000000000000000000000000000000 $new $ref" >&3
 447                                 freshen_loose_objects "$new"
 448                                 echo "0000000000000000000000000000000000000000 $new $ref"
 449                         done
 450                 git for-each-ref --format='%(objectname) %(objectname) %(refname)' refs/heads
 451                 echo "done ref-changes %$proj% $proj"
 452         } >.refs-temp 3>>"$logname"
 453         if [ -S "$sockpath" ]; then
 454                         trap ':' PIPE
 455                         nc_openbsd -w 15 -U "$sockpath" <.refs-temp || :
 456                         trap - PIPE
 457         fi
 458         bang config_set lastchange "$(date '+%a, %d %b %Y %T %z')"
 459         bang_eval "git for-each-ref --sort=-committerdate --format='%(committerdate:iso8601)' \
 460                 --count=1 refs/heads >info/lastactivity"
 461         ! [ -d htmlcache ] || { >htmlcache/changed; } 2>/dev/null || :
 462         rm -f .delaygc .allowgc
 463         if
 464                 [ "${cfg_autogchack:-0}" != "0" ] &&
 465                 [ "$(git config --get --bool girocco.autogchack 2>/dev/null)" != "false" ]
 466         then
 467                 mv -f .refs-after .refs-last
 468         fi
 469 fi
 470
 471 # If the repository does not yet have a valid HEAD symref try to set one
 472 # If an empty repository was cloned and then later becomes unempty you just
 473 # lose out on the fancy "symref=HEAD:" logic and get this version instead
 474 check_and_set_head || :
 475
 476 rm -f .refs-before .refs-after .refs-temp FETCH_HEAD
 477
 478 if is_banged; then
 479         [ -z "$mailaddrs" ] || ! was_banged_message_sent ||
 480         {
 481                 echo "$proj update succeeded - failure recovery"
 482                 echo "this status message may be disabled on the project admin page"
 483         } | mailref "update@$cfg_gitweburl/$proj.git" -s "[$cfg_name] $proj update succeeded" "$mailaddrs" || :
 484         bang_reset
 485 fi
 486
 487 progress "- [$proj] update ($(date))"