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 ] && [ "$_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 ] && [ "$_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" ] || [ "$cfg_admincc" = "0" ] || [ -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 ] && [ -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         } | mailref "clone@$cfg_gitweburl/$proj.git" -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" ] && [ -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 "$(ls -ldH "${url#file://}" 2>/dev/null | awk '{print $3}')"
 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                 test $? -eq 0
 281                 # remember the starting time so we can easily combine fetched loose objects
 282                 # we sleep for 1 second after creating .svnpack to make sure all objects are newer
 283                 if ! [ -e .svnpack ]; then
 284                         rm -f .svnpack
 285                         >.svnpack
 286                         sleep 1
 287                 fi
 288                 # Again, be careful to use GIT_DIR=. here or else new .git subdirectory!
 289                 GIT_DIR=. git svn fetch --log-window-size=$var_log_window_size --username=anonsvn --quiet </dev/null
 290                 # git svn does not preserve group permissions in the svn subdirectory
 291                 chmod -R ug+rw,o+r svn
 292                 # git svn also leaves behind ref turds that end with @nnn
 293                 # We get rid of them now
 294                 git for-each-ref --format='%(refname)' |
 295                 LC_ALL=C sed '/^..*@[1-9][0-9]*$/!d; s/^/delete /' |
 296                 git_updateref_stdin
 297                 unset GIT_ASKPASS_PASSWORD
 298                 ;;
 299         darcs://*)
 300                 [ -n "$cfg_mirror_darcs" ] || { echo "Mirroring darcs is disabled" >&2; exit 1; }
 301                 httpurl="http://${url#darcs://}"
 302                 git_darcs_fetch "$httpurl"
 303                 ;;
 304         bzr://*)
 305                 [ -n "$cfg_mirror_bzr" ] || { echo "Mirroring bzr is disabled" >&2; exit 1; }
 306                 # we just remove bzr:// here, a typical bzr url is just
 307                 # "lp:foo"
 308                 bzrurl="${url#bzr://}"
 309                 git_bzr_fetch "$bzrurl"
 310                 ;;
 311         hg+http://* | hg+https://* | hg+file://* | hg+ssh://*)
 312                 [ -n "$cfg_mirror_hg" ] || { echo "Mirroring hg is disabled" >&2; exit 1; }
 313                 # We just remove hg+ here, so hg+http://... becomes http://...
 314                 hgurl="${url#hg+}"
 315                 # Perform the initial hg clone
 316                 hg clone -U "$hgurl" "$(pwd)/repo.hg"
 317                 # Do the fast-export | fast-import
 318                 git_hg_fetch
 319                 ;;
 320         *)
 321                 # We manually add remote.origin.url and remote.origin.fetch
 322                 # to simulate a `git remote add --mirror=fetch` since that's
 323                 # not available until Git 1.7.5 and this way we guarantee we
 324                 # always get exactly the intended configuration and nothing else.
 325                 git config remote.origin.url "$url"
 326                 if ! is_gfi_mirror_url "$url" && [ "$(git config --bool girocco.cleanmirror 2>/dev/null || :)" = "true" ]; then
 327                         git config --replace-all remote.origin.fetch "+refs/heads/*:refs/heads/*"
 328                         git config --add remote.origin.fetch "+refs/tags/*:refs/tags/*"
 329                         git config --add remote.origin.fetch "+refs/notes/*:refs/notes/*"
 330                         git config --add remote.origin.fetch "+refs/top-bases/*:refs/top-bases/*"
 331                         git config --bool girocco.lastupdateclean true
 332                 else
 333                         git config --replace-all remote.origin.fetch "+refs/*:refs/*"
 334                         git config --bool girocco.lastupdateclean false
 335                 fi
 336                 # Set the correct HEAD symref by using ls-remote first
 337                 GIT_SSL_NO_VERIFY=1 GIT_TRACE_PACKET=1 git ls-remote origin >.refs-temp 2>.pkts-temp ||
 338                 {
 339                         # Since everything was redirected, on failure there'd be no output,
 340                         # so let's make some failure output
 341                         cat .pkts-temp
 342                         echo ""
 343                         echo "git ls-remote \"$url\" failed"
 344                         exit 1
 345                 }
 346                 # Compensate for git() {} side effects
 347                 unset GIT_TRACE_PACKET
 348                 # If the server is running at least Git 1.8.4.3 then it will send us the actual
 349                 # symref for HEAD.  If we are running at least Git 1.7.5 then we can snarf that
 350                 # out of the packet trace data.
 351                 if [ -s .refs-temp ]; then
 352                         # Nothing to do unless the remote repository has at least 1 ref
 353                         # See if we got a HEAD ref
 354                         head="$(LC_ALL=C grep -E "^$octet20[ $tab]+HEAD\$" <.refs-temp | LC_ALL=C awk '{print $1}')"
 355                         # If the remote has HEAD set to a symbolic ref that does not exist
 356                         # then we will not receive a HEAD ref in the ls-remote output
 357                         headref=
 358                         showheadwarn=
 359                         symrefcap=
 360                         if [ -n "$head" ]; then
 361                                 symrefcap="$(LC_ALL=C sed -ne <.pkts-temp \
 362                                         "/packet:.*git<.*[ $tab]symref="'HEAD:refs\/heads\/'"[^ $tab]/\
 363                                         {s/^.*[ $tab]symref="'HEAD:\(refs\/heads\/'"[^ $tab][^ $tab]*"'\).*$/\1/;p;}')"
 364                                 # prefer $symrefcap (refs/heads/master if no $symrefcap) if it
 365                                 # matches HEAD otherwise take the first refs/heads/... match
 366                                 matchcnt=0
 367                                 while read ref; do
 368                                         [ -n "$ref" ] || continue
 369                                         matchcnt=$(( $matchcnt + 1 ))
 370                                         if [ -z "$headref" ] || [ "$ref" = "${symrefcap:-refs/heads/master}" ]; then
 371                                                 headref="$ref"
 372                                         fi
 373                                         if [ "$headref" = "${symrefcap:-refs/heads/master}" ] && [ $matchcnt -gt 1 ]; then
 374                                                 break
 375                                         fi
 376                                 done <<-EOT
 377                                 $(LC_ALL=C grep -E "^$head[ $tab]+refs/heads/[^ $tab]+\$" <.refs-temp |
 378                                         LC_ALL=C awk '{print $2}')
 379                                 EOT
 380                                 # Warn if there was more than one match and $symrefcap is empty
 381                                 # or $symrefcap is not the same as $headref since our choice might
 382                                 # differ from the source repository's HEAD
 383                                 if [ $matchcnt -ge 1 ] && [ "$symrefcap" != "$headref" ] &&
 384                                    { [ -n "$symrefcap" ] || [ $matchcnt -gt 1 ]; }; then
 385                                         showheadwarn=1
 386                                 fi
 387                         fi
 388                         if [ -z "$headref" ]; then
 389                                 # If we still don't have a HEAD ref then prefer refs/heads/master
 390                                 # if it exists otherwise take the first refs/heads/...
 391                                 # We do not support having a detached HEAD.
 392                                 # We always warn now because we will be setting HEAD differently
 393                                 # than the source repository had HEAD set
 394                                 showheadwarn=1
 395                                 while read ref; do
 396                                         [ -n "$ref" ] || continue
 397                                         if [ -z "$headref" ] || [ "$ref" = "refs/heads/master" ]; then
 398                                                 headref="$ref"
 399                                         fi
 400                                         [ "$headref" != "refs/heads/master" ] || break
 401                                 done <<-EOT
 402                                 $(LC_ALL=C grep -E "^$octet20[ $tab]+refs/heads/[^ $tab]+\$" <.refs-temp |
 403                                         LC_ALL=C awk '{print $2}')
 404                                 EOT
 405                         fi
 406                         # If we STILL do not have a HEAD ref (perhaps the source repository
 407                         # contains only tags) then use refs/heads/master.  It will be invalid
 408                         # but is no worse than we used to do by default and we'll warn about
 409                         # it.  We do not support a HEAD symref to anything other than refs/heads/...
 410                         [ -n "$headref" ] || headref="refs/heads/master"
 411                         git symbolic-ref HEAD "$headref"
 412                         pruneopt=--prune
 413                         [ "$(git config --bool fetch.prune 2>/dev/null || :)" != "false" ] || pruneopt=
 414                         # remember the starting time so we can easily detect new packs for fast-import mirrors
 415                         # we sleep for 1 second after creating .gfipack to make sure all packs are newer
 416                         if is_gfi_mirror_url "$url" && ! [ -e .gfipack ]; then
 417                                 rm -f .gfipack
 418                                 >.gfipack
 419                                 sleep 1
 420                         fi
 421                         GIT_SSL_NO_VERIFY=1 git remote update $pruneopt
 422                         if [ -e .gfipack ] && is_gfi_mirror_url "$url"; then
 423                                 find objects/pack -type f -newer .gfipack -name "pack-$octet20.pack" -print >>gfi-packs
 424                                 rm -f .gfipack
 425                         fi
 426                 else
 427                         warnempty=1
 428                         git symbolic-ref HEAD "refs/heads/master"
 429                 fi
 430                 rm -f .refs-temp .pkts-temp
 431                 ;;
 432 esac
 433
 434 # The objects subdirectories permissions must be updated now.
 435 # In the case of a dumb http clone, the permissions will not be correct
 436 # (missing group write) despite the core.sharedrepository=1 setting!
 437 # The objects themselves seem to have the correct permissions.
 438 # This problem appears to have been fixed in the most recent git versions.
 439 perms=g+w
 440 [ "$cfg_permission_control" != "Hooks" ] || perms=go+w
 441 chmod $perms $(find objects -maxdepth 1 -type d) 2>/dev/null || :
 442
 443 # We may have just cloned a lot of refs and they will all be
 444 # individual files at this point.  Let's pack them now so we
 445 # can have better performance right from the start.
 446 git pack-refs --all
 447
 448 # Initialize gitweb.lastreceive, gitweb.lastchange and info/lastactivity
 449 git config gitweb.lastreceive "$(date '+%a, %d %b %Y %T %z')"
 450 git config gitweb.lastchange "$(date '+%a, %d %b %Y %T %z')"
 451 git for-each-ref --sort=-committerdate --format='%(committerdate:iso8601)' \
 452         --count=1 refs/heads >info/lastactivity || :
 453 ! [ -d htmlcache ] || { >htmlcache/changed; } 2>/dev/null || :
 454
 455 # Don't leave a multi-megabyte useless FETCH_HEAD behind
 456 rm -f FETCH_HEAD
 457
 458 # Last ditch attempt to get a valid HEAD for a non-git source
 459 check_and_set_head || :
 460
 461 # The rest
 462 echo "Final touches..."
 463 git update-server-info
 464 trap "" EXIT
 465
 466 # run gc now unless the clone is empty
 467 if [ -z "$warnempty" ]; then
 468         git config --unset gitweb.lastgc 2>/dev/null || :
 469         rm -f .delaygc .allowgc
 470 fi
 471
 472 emptynote=
 473 [ -z "$warnempty" ] ||
 474 emptynote="
 475 WARNING:  You have mirrored an empty repository.
 476 "
 477 headnote=
 478 [ -z "$showheadwarn" ] || [ -z "$headref" ] ||
 479 headnote="
 480 NOTE:  HEAD has been set to a symbolic ref to \"$headref\".
 481        Use the \"Project settings\" link to choose a different HEAD symref.
 482 "
 483 sizenote=
 484 ! is_gfi_mirror ||
 485 sizenote="
 486 NOTE:  Since this is a mirror of a non-Git source, the initial repository
 487        size may be somewhat larger than necessary.  This will be corrected
 488        shortly.  If you intend to clone this repository you may want to
 489        wait up to 1 hour before doing so in order to receive the more
 490        compact final size.
 491 "
 492 [ -z "$mailaddrs" ] ||
 493 mailref "clone@$cfg_gitweburl/$proj.git" -s "[$cfg_name] $proj clone completed" "$mailaddrs" <<EOT || :
 494 Congratulations! The clone of project $proj just completed.
 495
 496         * Source URL: $url
 497         * GitWeb interface: $cfg_gitweburl/$proj.git
 498         * Project settings: $cfg_webadmurl/editproj.cgi?name=$(echo "$proj" | LC_ALL=C sed -e 's/[+]/%2B/g')
 499 $emptynote$headnote$sizenote
 500 Have a lot of fun.
 501 EOT
 502
 503 echo "Mirroring finished successfuly!"
 504 # In case this is a re-mirror, lastgc could have been set already so clear it now
 505 git config --unset gitweb.lastgc || :
 506 rm .clone_in_progress
 507 echo "$sizenote@OVER@"