taskd/clone.sh

   1 #!/bin/sh
   2 #
   3 # Invoked from taskd/taskd.pl
   4
   5 . @basedir@/shlib.sh
   6
   7 set -e
   8
   9 umask 002
  10 [ "$cfg_permission_control" != "Hooks" ] || umask 000
  11 clean_git_env
  12
  13 # darcs fast-export | git fast-import with error handling
  14 git_darcs_fetch() (
  15         set_utf8_locale
  16         _err1=
  17         _err2=
  18         exec 3>&1
  19         { read -r _err1 || :; read -r _err2 || :; } <<-EOT
  20         $(
  21                 exec 4>&3 3>&1 1>&4 4>&-
  22                 {
  23                         _e1=0
  24                         "$cfg_basedir"/bin/darcs-fast-export \
  25                                 --export-marks="$(pwd)/dfe-marks" "$1" 3>&- || _e1=$?
  26                         echo $_e1 >&3
  27                 } | \
  28                 {
  29                         _e2=0
  30                         git fast-import \
  31                                 --export-marks="$(pwd)/gfi-marks" \
  32                                 --export-pack-edges="$(pwd)/gfi-packs" \
  33                                 --force 3>&- || _e2=$?
  34                         echo $_e2 >&3
  35                 }
  36         )
  37         EOT
  38         exec 3>&-
  39         [ "$_err1" = 0 -a "$_err2" = 0 ]
  40         return $?
  41 )
  42
  43 # bzr fast-export | git fast-import with error handling
  44 git_bzr_fetch() (
  45         set_utf8_locale
  46         BZR_LOG=/dev/null
  47         export BZR_LOG
  48         _err1=
  49         _err2=
  50         exec 3>&1
  51         { read -r _err1 || :; read -r _err2 || :; } <<-EOT
  52         $(
  53                 exec 4>&3 3>&1 1>&4 4>&-
  54                 {
  55                         _e1=0
  56                         bzr fast-export --plain \
  57                                 --export-marks="$(pwd)/bfe-marks" "$1" 3>&- || _e1=$?
  58                         echo $_e1 >&3
  59                 } | \
  60                 {
  61                         _e2=0
  62                         git fast-import \
  63                                 --export-marks="$(pwd)/gfi-marks" \
  64                                 --export-pack-edges="$(pwd)/gfi-packs" \
  65                                 --force 3>&- || _e2=$?
  66                         echo $_e2 >&3
  67                 }
  68         )
  69         EOT
  70         exec 3>&-
  71         [ "$_err1" = 0 -a "$_err2" = 0 ]
  72         return $?
  73 )
  74
  75 send_clone_failed() {
  76         trap "" EXIT
  77         # We must now close the .clonelog file that is open on stdout and stderr
  78         exec >/dev/null 2>&1
  79         failaddrs="$(config_get owner || :)"
  80         [ -z "$cfg_admincc" -o "$cfg_admincc" = "0" -o -z "$cfg_admin" ] || \
  81         if [ -z "$failaddrs" ]; then failaddrs="$cfg_admin"; else failaddrs="$failaddrs,$cfg_admin"; fi
  82         [ -z "$failaddrs" ] || \
  83         {
  84               cat <<EOT
  85 Condolences. The clone of project $proj just failed.
  86
  87         * Source URL: $url
  88         * Project settings: $cfg_webadmurl/editproj.cgi?name=$(echo "$proj" | LC_ALL=C sed -e 's/[+]/%2B/g')
  89
  90 The project settings link may be used to adjust the settings
  91 and restart the clone in order to try the clone again.
  92 EOT
  93                 if [ -f .clonelog -a -r .clonelog ]; then
  94                         echo ""
  95                         echo "Log follows:"
  96                         echo ""
  97                         loglines=$(LC_ALL=C wc -l <.clonelog)
  98                         if [ $loglines -le 203 ]; then
  99                                 cat .clonelog
 100                         else
 101                                 head -n 100 .clonelog
 102                                 echo ""
 103                                 echo "[ ... elided $(( $loglines - 200 )) middle lines ... ]"
 104                                 echo ""
 105                                 tail -n 100 .clonelog
 106                         fi
 107                 fi
 108         } | mail -s "[$cfg_name] $proj clone failed" "$failaddrs" || :
 109 }
 110
 111 # removes all leftovers from a previous failed clone attempt
 112 cleanup_failed_clone() {
 113
 114         # Remove any left-over svn-remote.svn or remote.origin config
 115         git config --remove-section svn-remote.svn 2>/dev/null || :
 116         git config --remove-section remote.origin 2>/dev/null || :
 117
 118         # If there is a remote-template.origin section, pre-seed the
 119         # remote.origin section with its contents
 120         git config --get-regexp '^remote-template\.origin\..' |
 121         while read name value; do
 122                 if [ -n "$name" -a -n "$value" ]; then
 123                         git config "remote${name#remote-template}" "$value"
 124                 fi
 125         done
 126
 127         # Any pre-existing FETCH_HEAD from a previous clone failed or not is
 128         # now garbage to be removed
 129         rm -f FETCH_HEAD
 130
 131         # Remove any left-over svn dir from a previous failed attempt
 132         rm -rf svn
 133
 134         # Remove any left-over .darcs dirs from a previous failed attempt
 135         rm -rf *.darcs
 136
 137         # Remove any left-over repo.hg dir from a previous failed attempt
 138         rm -rf repo.hg
 139
 140         # Remove any left-over import/export/temp files from a previous failed attempt
 141         rm -f bfe-marks dfe-marks hg2git-heads hg2git-mapping hg2git-marks* hg2git-state \
 142                 gfi-marks gfi-packs .pkts-temp .refs-temp
 143
 144         # We want a gc right after the clone, so re-enable that just in case.
 145         # There's a potential race where we could add it and gc.sh could remove
 146         # it, but we'll reunset lastgc just before we remove .delaygc at the end.
 147         [ -e .delaygc ] || >.delaygc
 148         git config --unset gitweb.lastgc 2>/dev/null || :
 149
 150         # Remove all pre-existing refs
 151         rm -f packed-refs
 152         git for-each-ref --format='delete %(refname)' | git_updateref_stdin 2>/dev/null || :
 153
 154         # The initial state before a clone starts has HEAD as a symbolic-ref to master
 155         git symbolic-ref HEAD refs/heads/master
 156
 157         # HEAD is no longer "ok"
 158         git config --unset girocco.headok 2>/dev/null || :
 159
 160         # We, perhaps, ought to remove any packs/loose objects now, but the next gc
 161         # will get rid of any extras.  Also, if we're recloning the same thing, any
 162         # preexisting packs/loose objects containing what we're recloning will only
 163         # speed up the reclone by avoiding some disk writes.  So we don't kill them.
 164 }
 165
 166 proj="${1%.git}"
 167 cd "$cfg_reporoot/$proj.git"
 168 bang_reset
 169
 170 ! [ -e .delaygc ] || >.allowgc || :
 171
 172 trap "echo '@OVER@'; touch .clone_failed; send_clone_failed" EXIT
 173 echo "Project: $proj"
 174 echo ""
 175 [ -n "$cfg_mirror" ] || { echo "Mirroring is disabled" >&2; exit 1; }
 176 url="$(config_get baseurl || :)"
 177 case "$url" in *"       "*|*" "*|"")
 178         echo "Bad mirror URL (\"$url\")"
 179         exit 1
 180 esac
 181
 182 cleanup_failed_clone
 183
 184 # Record original mirror type for use by update.sh
 185 mirror_type="$(get_url_mirror_type "$url")"
 186 git config girocco.mirrortype "$mirror_type"
 187
 188 echo "Mirroring from URL \"$url\""
 189 echo ""
 190
 191 if [ "$cfg_project_owners" = "source" ]; then
 192         config_set owner "$(stat -c %U "$url" 2>/dev/null)"
 193 fi
 194
 195 mailaddrs="$(config_get owner || :)"
 196 [ -z "$cfg_admin" ] || \
 197 if [ -z "$mailaddrs" ]; then mailaddrs="$cfg_admin"; else mailaddrs="$mailaddrs,$cfg_admin"; fi
 198
 199 # Make sure we don't get any unwanted loose objects
 200 # Starting with Git v2.10.0 fast-import can generate loose objects unless we
 201 # tweak its configuration to prevent that
 202 git_add_config 'fetch.unpackLimit=1'
 203 # Note the git config documentation is wrong
 204 # transfer.unpackLimit, if set, overrides fetch.unpackLimit
 205 git_add_config 'transfer.unpackLimit=1'
 206 # But not the Git v2.10.0 and later fastimport.unpackLimit which improperly uses <= instead of <
 207 git_add_config 'fastimport.unpackLimit=0'
 208
 209 # Initial mirror
 210 echo "Initiating mirroring..."
 211 headref=
 212 showheadwarn=
 213 warnempty=
 214 case "$url" in
 215         svn://* | svn+http://* | svn+https://* | svn+file://* | svn+ssh://*)
 216                 [ -n "$cfg_mirror_svn" ] || { echo "Mirroring svn is disabled" >&2; exit 1; }
 217                 # We just remove svn+ here, so svn+http://... becomes http://...
 218                 # We also remove a trailing '/' to match what git-svn will do
 219                 case "$url" in svn+ssh://*) svnurl="$url";; *) svnurl="${url#svn+}";; esac
 220                 svnurl="${svnurl%/}"
 221                 # Use an 'anonsvn' username as is commonly used for anonymous svn
 222                 # Use an 'anonsvn' password as is commonly used for anonymous svn
 223                 GIT_ASKPASS_PASSWORD=anonsvn
 224                 export GIT_ASKPASS_PASSWORD
 225                 # We require svn info to succeed on the URL otherwise it's
 226                 # simply not a valid URL and without using -s on the init it
 227                 # will not otherwise be tested until the fetch
 228                 svn --non-interactive --username anonsvn --password anonsvn info "$svnurl" > /dev/null
 229                 # We initially use -s for the init which will possibly shorten
 230                 # the URL.  However, the shortening can fail if a password is
 231                 # not required for the longer version but is for the shorter,
 232                 # so try again without -s if the -s version fails.
 233                 # We must use GIT_DIR=. here or ever so "helpful" git-svn will
 234                 # create a .git subdirectory!
 235                 GIT_DIR=. git svn init --username=anonsvn --prefix "" -s "$svnurl" < /dev/null || \
 236                 GIT_DIR=. git svn init --username=anonsvn --prefix "" "$svnurl" < /dev/null
 237                 # We need to remember this url so we can detect changes because
 238                 # ever so "helpful" git-svn may shorten it!
 239                 config_set svnurl "$svnurl"
 240                 # At this point, since we asked for a standard layout (-s) git-svn
 241                 # may have been "helpful" and adjusted our $svnurl to a prefix and
 242                 # then glued the removed suffix onto the front of any svn-remote.svn.*
 243                 # config items.  We could avoid this by not using the '-s' option
 244                 # but then we might not get all the history.  If, for example, we
 245                 # are cloning an http://svn.example.com/repos/public repository that
 246                 # early in its history moved trunk => public/trunk we would miss that
 247                 # earlier history without allowing the funky shorten+prefix behavior.
 248                 # So we read back the svn-remote.svn.fetch configuration and compute
 249                 # the prefix.  This way we are sure to get the correct prefix.
 250                 gitsvnurl="$(git config --get svn-remote.svn.url || :)"
 251                 gitsvnfetch="$(git config --get-all svn-remote.svn.fetch | tail -1 || :)"
 252                 gitsvnprefix="${gitsvnfetch%%:*}"
 253                 gitsvnsuffix="${gitsvnprefix##*/}"
 254                 gitsvnprefix="${gitsvnprefix%$gitsvnsuffix}"
 255                 # Ask git-svn to store everything in the normal non-remote
 256                 # locations being careful to use the correct prefix
 257                 git config --replace-all svn-remote.svn.fetch "${gitsvnprefix}trunk:refs/heads/master"
 258                 git config --replace-all svn-remote.svn.branches "${gitsvnprefix}branches/*:refs/heads/*"
 259                 git config --replace-all svn-remote.svn.tags "${gitsvnprefix}tags/*:refs/tags/*"
 260                 # look for additional non-standard directories to fetch
 261                 # check for standard layout at the same time
 262                 foundstd=
 263                 foundfile=
 264                 { svn --non-interactive --username anonsvn --password anonsvn ls "$gitsvnurl/${gitsvnprefix}" 2>/dev/null || :; } | \
 265                 { while read file; do case $file in
 266                         # skip the already-handled standard ones and any with a space or tab
 267                         *'      '*|*' '*) :;;
 268                         trunk/|branches/|tags/) foundstd=1;;
 269                         # only fetch extra directories from the $svnurl root (not any files)
 270                         *?/) git config --add svn-remote.svn.fetch \
 271                                 "${gitsvnprefix}${file%/}:refs/heads/${file%/}";;
 272                         *?) foundfile=1;;
 273                 esac; done
 274                 # if files found and no standard directories present use a simpler layout
 275                 if [ -z "$foundstd" ] && [ -n "$foundfile" ]; then
 276                         git config --unset svn-remote.svn.branches
 277                         git config --unset svn-remote.svn.tags
 278                         git config --replace-all svn-remote.svn.fetch ':refs/heads/master'
 279                 fi; }
 280                 # remember the starting time so we can easily combine fetched loose objects
 281                 # we sleep for 1 second after creating .svnpack to make sure all objects are newer
 282                 if ! [ -e .svnpack ]; then
 283                         rm -f .svnpack
 284                         >.svnpack
 285                         sleep 1
 286                 fi
 287                 # Again, be careful to use GIT_DIR=. here or else new .git subdirectory!
 288                 GIT_DIR=. git svn fetch --log-window-size=$var_log_window_size --username=anonsvn --quiet < /dev/null
 289                 # git svn does not preserve group permissions in the svn subdirectory
 290                 chmod -R ug+rw,o+r svn
 291                 # git svn also leaves behind ref turds that end with @nnn
 292                 # We get rid of them now
 293                 git for-each-ref --format='%(refname)' |
 294                 LC_ALL=C sed '/^..*@[1-9][0-9]*$/!d; s/^/delete /' |
 295                 git_updateref_stdin
 296                 unset GIT_ASKPASS_PASSWORD
 297                 ;;
 298         darcs://*)
 299                 [ -n "$cfg_mirror_darcs" ] || { echo "Mirroring darcs is disabled" >&2; exit 1; }
 300                 httpurl="http://${url#darcs://}"
 301                 git_darcs_fetch "$httpurl"
 302                 ;;
 303         bzr://*)
 304                 [ -n "$cfg_mirror_bzr" ] || { echo "Mirroring bzr is disabled" >&2; exit 1; }
 305                 # we just remove bzr:// here, a typical bzr url is just
 306                 # "lp:foo"
 307                 bzrurl="${url#bzr://}"
 308                 git_bzr_fetch "$bzrurl"
 309                 ;;
 310         hg+http://* | hg+https://* | hg+file://* | hg+ssh://*)
 311                 [ -n "$cfg_mirror_hg" ] || { echo "Mirroring hg is disabled" >&2; exit 1; }
 312                 # We just remove hg+ here, so hg+http://... becomes http://...
 313                 hgurl="${url#hg+}"
 314                 # Perform the initial hg clone
 315                 hg clone -U "$hgurl" "$(pwd)/repo.hg"
 316                 # Do the fast-export | fast-import
 317                 git_hg_fetch
 318                 ;;
 319         *)
 320                 # We manually add remote.origin.url and remote.origin.fetch
 321                 # to simulate a `git remote add --mirror=fetch` since that's
 322                 # not available until Git 1.7.5 and this way we guarantee we
 323                 # always get exactly the intended configuration and nothing else.
 324                 git config remote.origin.url "$url"
 325                 if ! is_gfi_mirror_url "$url" && [ "$(git config --bool girocco.cleanmirror 2>/dev/null || :)" = "true" ]; then
 326                         git config --replace-all remote.origin.fetch "+refs/heads/*:refs/heads/*"
 327                         git config --add remote.origin.fetch "+refs/tags/*:refs/tags/*"
 328                         git config --add remote.origin.fetch "+refs/notes/*:refs/notes/*"
 329                         git config --add remote.origin.fetch "+refs/top-bases/*:refs/top-bases/*"
 330                         git config --bool girocco.lastupdateclean true
 331                 else
 332                         git config --replace-all remote.origin.fetch "+refs/*:refs/*"
 333                         git config --bool girocco.lastupdateclean false
 334                 fi
 335                 # Set the correct HEAD symref by using ls-remote first
 336                 GIT_SSL_NO_VERIFY=1 GIT_TRACE_PACKET=1 git ls-remote origin >.refs-temp 2>.pkts-temp || \
 337                 {
 338                         # Since everything was redirected, on failure there'd be no output,
 339                         # so let's make some failure output
 340                         cat .pkts-temp
 341                         echo ""
 342                         echo "git ls-remote \"$url\" failed"
 343                         exit 1
 344                 }
 345                 # Compensate for git() {} side effects
 346                 unset GIT_TRACE_PACKET
 347                 # If the server is running at least Git 1.8.4.3 then it will send us the actual
 348                 # symref for HEAD.  If we are running at least Git 1.7.5 then we can snarf that
 349                 # out of the packet trace data.
 350                 if [ -s .refs-temp ]; then
 351                         # Nothing to do unless the remote repository has at least 1 ref
 352                         # See if we got a HEAD ref
 353                         head="$(LC_ALL=C grep -E "^$octet20[ $tab]+HEAD\$" <.refs-temp | LC_ALL=C awk '{print $1}')"
 354                         # If the remote has HEAD set to a symbolic ref that does not exist
 355                         # then we will not receive a HEAD ref in the ls-remote output
 356                         headref=
 357                         showheadwarn=
 358                         symrefcap=
 359                         if [ -n "$head" ]; then
 360                                 symrefcap="$(LC_ALL=C sed -ne <.pkts-temp \
 361                                         "/packet:.*git<.*[ $tab]symref="'HEAD:refs\/heads\/'"[^ $tab]/\
 362                                         {s/^.*[ $tab]symref="'HEAD:\(refs\/heads\/'"[^ $tab][^ $tab]*"'\).*$/\1/;p;}')"
 363                                 # prefer $symrefcap (refs/heads/master if no $symrefcap) if it
 364                                 # matches HEAD otherwise take the first refs/heads/... match
 365                                 matchcnt=0
 366                                 while read ref; do
 367                                         [ -n "$ref" ] || continue
 368                                         matchcnt=$(( $matchcnt + 1 ))
 369                                         if [ -z "$headref" ] || [ "$ref" = "${symrefcap:-refs/heads/master}" ]; then
 370                                                 headref="$ref"
 371                                         fi
 372                                         [ "$headref" = "${symrefcap:-refs/heads/master}" -a $matchcnt -gt 1 ] && break
 373                                 done <<-EOT
 374                                 $(LC_ALL=C grep -E "^$head[ $tab]+refs/heads/[^ $tab]+\$" <.refs-temp | \
 375                                         LC_ALL=C awk '{print $2}')
 376                                 EOT
 377                                 # Warn if there was more than one match and $symrefcap is empty
 378                                 # or $symrefcap is not the same as $headref since our choice might
 379                                 # differ from the source repository's HEAD
 380                                 if [ $matchcnt -ge 1 -a "$symrefcap" != "$headref" ] && \
 381                                    [ -n "$symrefcap" -o $matchcnt -gt 1 ]; then
 382                                         showheadwarn=1
 383                                 fi
 384                         fi
 385                         if [ -z "$headref" ]; then
 386                                 # If we still don't have a HEAD ref then prefer refs/heads/master
 387                                 # if it exists otherwise take the first refs/heads/...
 388                                 # We do not support having a detached HEAD.
 389                                 # We always warn now because we will be setting HEAD differently
 390                                 # than the source repository had HEAD set
 391                                 showheadwarn=1
 392                                 while read ref; do
 393                                         [ -n "$ref" ] || continue
 394                                         if [ -z "$headref" ] || [ "$ref" = "refs/heads/master" ]; then
 395                                                 headref="$ref"
 396                                         fi
 397                                         [ "$headref" = "refs/heads/master" ] && break
 398                                 done <<-EOT
 399                                 $(LC_ALL=C grep -E "^$octet20[ $tab]+refs/heads/[^ $tab]+\$" <.refs-temp | \
 400                                         LC_ALL=C awk '{print $2}')
 401                                 EOT
 402                         fi
 403                         # If we STILL do not have a HEAD ref (perhaps the source repository
 404                         # contains only tags) then use refs/heads/master.  It will be invalid
 405                         # but is no worse than we used to do by default and we'll warn about
 406                         # it.  We do not support a HEAD symref to anything other than refs/heads/...
 407                         [ -n "$headref" ] || headref="refs/heads/master"
 408                         git symbolic-ref HEAD "$headref"
 409                         pruneopt=--prune
 410                         [ "$(git config --bool fetch.prune 2>/dev/null || :)" != "false" ] || pruneopt=
 411                         # remember the starting time so we can easily detect new packs for fast-import mirrors
 412                         # we sleep for 1 second after creating .gfipack to make sure all packs are newer
 413                         if is_gfi_mirror_url "$url" && [ ! -e .gfipack ]; then
 414                                 rm -f .gfipack
 415                                 >.gfipack
 416                                 sleep 1
 417                         fi
 418                         GIT_SSL_NO_VERIFY=1 git remote update $pruneopt
 419                         if [ -e .gfipack ] && is_gfi_mirror_url "$url"; then
 420                                 find objects/pack -type f -newer .gfipack -name "pack-$octet20.pack" -print >>gfi-packs
 421                                 rm -f .gfipack
 422                         fi
 423                 else
 424                         warnempty=1
 425                         git symbolic-ref HEAD "refs/heads/master"
 426                 fi
 427                 rm -f .refs-temp .pkts-temp
 428                 ;;
 429 esac
 430
 431 # The objects subdirectories permissions must be updated now.
 432 # In the case of a dumb http clone, the permissions will not be correct
 433 # (missing group write) despite the core.sharedrepository=1 setting!
 434 # The objects themselves seem to have the correct permissions.
 435 # This problem appears to have been fixed in the most recent git versions.
 436 perms=g+w
 437 [ "$cfg_permission_control" != "Hooks" ] || perms=go+w
 438 chmod $perms $(find objects -maxdepth 1 -type d) 2>/dev/null || :
 439
 440 # We may have just cloned a lot of refs and they will all be
 441 # individual files at this point.  Let's pack them now so we
 442 # can have better performance right from the start.
 443 git pack-refs --all
 444
 445 # Initialize gitweb.lastreceive, gitweb.lastchange and info/lastactivity
 446 git config gitweb.lastreceive "$(date '+%a, %d %b %Y %T %z')"
 447 git config gitweb.lastchange "$(date '+%a, %d %b %Y %T %z')"
 448 git for-each-ref --sort=-committerdate --format='%(committerdate:iso8601)' \
 449         --count=1 refs/heads > info/lastactivity || :
 450 ! [ -d htmlcache ] || { >htmlcache/changed; } 2>/dev/null || :
 451
 452 # Don't leave a multi-megabyte useless FETCH_HEAD behind
 453 rm -f FETCH_HEAD
 454
 455 # Last ditch attempt to get a valid HEAD for a non-git source
 456 check_and_set_head || :
 457
 458 # The rest
 459 echo "Final touches..."
 460 git update-server-info
 461 trap "" EXIT
 462
 463 # run gc now unless the clone is empty
 464 if [ -z "$warnempty" ]; then
 465         git config --unset gitweb.lastgc 2>/dev/null || :
 466         rm -f .delaygc .allowgc
 467 fi
 468
 469 emptynote=
 470 [ -z "$warnempty" ] ||
 471 emptynote="
 472 WARNING:  You have mirrored an empty repository.
 473 "
 474 headnote=
 475 [ -n "$showheadwarn" -a -n "$headref" ] &&
 476 headnote="
 477 NOTE:  HEAD has been set to a symbolic ref to \"$headref\".
 478        Use the \"Project settings\" link to choose a different HEAD symref.
 479 "
 480 sizenote=
 481 ! is_gfi_mirror ||
 482 sizenote="
 483 NOTE:  Since this is a mirror of a non-Git source, the initial repository
 484        size may be somewhat larger than necessary.  This will be corrected
 485        shortly.  If you intend to clone this repository you may want to
 486        wait up to 1 hour before doing so in order to receive the more
 487        compact final size.
 488 "
 489 [ -z "$mailaddrs" ] ||
 490 mail -s "[$cfg_name] $proj clone completed" "$mailaddrs" <<EOT || :
 491 Congratulations! The clone of project $proj just completed.
 492
 493         * Source URL: $url
 494         * GitWeb interface: $cfg_gitweburl/$proj.git
 495         * Project settings: $cfg_webadmurl/editproj.cgi?name=$(echo "$proj" | LC_ALL=C sed -e 's/[+]/%2B/g')
 496 $emptynote$headnote$sizenote
 497 Have a lot of fun.
 498 EOT
 499
 500 echo "Mirroring finished successfuly!"
 501 # In case this is a re-mirror, lastgc could have been set already so clear it now
 502 git config --unset gitweb.lastgc || :
 503 rm .clone_in_progress
 504 echo "$sizenote@OVER@"