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         ! [ -d htmlcache ] || { >htmlcache/changed; } 2>/dev/null || :
  80         failaddrs="$(config_get owner)" || :
  81         [ -z "$cfg_admincc" ] || [ "$cfg_admincc" = "0" ] || [ -z "$cfg_admin" ] ||
  82         if [ -z "$failaddrs" ]; then failaddrs="$cfg_admin"; else failaddrs="$failaddrs,$cfg_admin"; fi
  83         [ -z "$failaddrs" ] ||
  84         {
  85               cat <<EOT
  86 Condolences. The clone of project $proj just failed.
  87
  88         * Source URL: $url
  89         * Project settings: $cfg_webadmurl/editproj.cgi?name=$(echo "$proj" | LC_ALL=C sed -e 's/[+]/%2B/g')
  90
  91 The project settings link may be used to adjust the settings
  92 and restart the clone in order to try the clone again.
  93 EOT
  94                 if [ -f .clonelog ] && [ -r .clonelog ]; then
  95                         echo ""
  96                         echo "Log follows:"
  97                         echo ""
  98                         loglines=$(LC_ALL=C wc -l <.clonelog)
  99                         if [ $loglines -le 203 ]; then
 100                                 cat .clonelog
 101                         else
 102                                 head -n 100 .clonelog
 103                                 echo ""
 104                                 echo "[ ... elided $(( $loglines - 200 )) middle lines ... ]"
 105                                 echo ""
 106                                 tail -n 100 .clonelog
 107                         fi
 108                 fi
 109         } | mailref "clone@$cfg_gitweburl/$proj.git" -s "[$cfg_name] $proj clone failed" "$failaddrs" || :
 110 }
 111
 112 # removes any git-svn leftovers
 113 cleanup_git_svn_leftovers() {
 114
 115         # Remove any stale git-svn temp files
 116         # The git-svn process creates temp files with random 10 character names
 117         # in the root of $GIT_DIR.  Unfortunately they do not have a recognizable
 118         # prefix, so we just have to kill any files with a 10-character name.
 119         # All characters are chosen from
 120         # [A-Za-z0-9_] so we can at least check that and fortunately the only
 121         # collision is 'FETCH_HEAD' but that doesn't matter.
 122         # There may also be temp files with a Git_ prefix as well.
 123         _randchar='[A-Za-z0-9_]'
 124         _randchar2="$_randchar$_randchar"
 125         _randchar4="$_randchar2$_randchar2"
 126         _randchar10="$_randchar4$_randchar4$_randchar2"
 127         find -L . -maxdepth 1 -type f -name "$_randchar10" -exec rm -f '{}' + || :
 128         find -L . -maxdepth 1 -type f -name "Git_*" -exec rm -f '{}' + || :
 129 }
 130
 131 # removes all leftovers from a previous failed clone attempt
 132 cleanup_failed_clone() {
 133
 134         # Remove any left-over svn-remote.svn or remote.origin config
 135         git config --remove-section svn-remote.svn 2>/dev/null || :
 136         git config --remove-section remote.origin 2>/dev/null || :
 137
 138         # If there is a remote-template.origin section, pre-seed the
 139         # remote.origin section with its contents
 140         git config --get-regexp '^remote-template\.origin\..' |
 141         while read name value; do
 142                 if [ -n "$name" ] && [ -n "$value" ]; then
 143                         git config "remote${name#remote-template}" "$value"
 144                 fi
 145         done
 146
 147         # Any pre-existing FETCH_HEAD from a previous clone failed or not is
 148         # now garbage to be removed
 149         rm -f FETCH_HEAD
 150
 151         # Remove any left-over svn dir from a previous failed attempt
 152         rm -rf svn
 153
 154         # Remove any left-over .darcs dirs from a previous failed attempt
 155         rm -rf *.darcs
 156
 157         # Remove any left-over repo.hg dir from a previous failed attempt
 158         rm -rf repo.hg
 159
 160         # Remove any left-over import/export/temp files from a previous failed attempt
 161         rm -f bfe-marks dfe-marks hg2git-heads hg2git-mapping hg2git-marks* hg2git-state \
 162                 gfi-marks gfi-packs .pkts-temp .refs-temp
 163
 164         # Remove any git-svn junk
 165         cleanup_git_svn_leftovers
 166
 167         # We want a gc right after the clone, so re-enable that just in case.
 168         # There's a potential race where we could add it and gc.sh could remove
 169         # it, but we'll reunset lastgc just before we remove .delaygc at the end.
 170         [ -e .delaygc ] || >.delaygc
 171         git config --unset gitweb.lastgc 2>/dev/null || :
 172
 173         # Remove all pre-existing refs
 174         rm -f packed-refs
 175         git for-each-ref --format='delete %(refname)' | git_updateref_stdin 2>/dev/null || :
 176
 177         # The initial state before a clone starts has HEAD as a symbolic-ref to master
 178         git symbolic-ref HEAD refs/heads/master
 179
 180         # HEAD is no longer "ok"
 181         git config --unset girocco.headok 2>/dev/null || :
 182
 183         # We, perhaps, ought to remove any packs/loose objects now, but the next gc
 184         # will get rid of any extras.  Also, if we're recloning the same thing, any
 185         # preexisting packs/loose objects containing what we're recloning will only
 186         # speed up the reclone by avoiding some disk writes.  So we don't kill them.
 187
 188         # It's just remotely possible that a bunch of failures in a row could
 189         # create a big mess that just keeps growing and growing...
 190         # Trigger a .needsgc if that happens.
 191         check_and_set_needsgc
 192 }
 193
 194 proj="${1%.git}"
 195 cd "$cfg_reporoot/$proj.git"
 196 bang_reset
 197
 198 ! [ -e .delaygc ] || >.allowgc || :
 199
 200 trap "echo '@OVER@'; touch .clone_failed; send_clone_failed" EXIT
 201 echo "Project: $proj"
 202 echo "   Date: $(TZ=UTC date '+%Y-%m-%d %T UTC')"
 203 echo ""
 204 [ -n "$cfg_mirror" ] || { echo "Mirroring is disabled" >&2; exit 1; }
 205 url="$(config_get baseurl)" || :
 206 case "$url" in *"       "*|*" "*|"")
 207         echo "Bad mirror URL (\"$url\")"
 208         exit 1
 209 esac
 210
 211 cleanup_failed_clone
 212
 213 # Record original mirror type for use by update.sh
 214 mirror_type="$(get_url_mirror_type "$url")"
 215 git config girocco.mirrortype "$mirror_type"
 216
 217 echo "Mirroring from URL \"$url\""
 218 echo ""
 219
 220 if [ "$cfg_project_owners" = "source" ]; then
 221         config set owner "$(ls -ldH "${url#file://}" 2>/dev/null | LC_ALL=C awk '{print $3}')"
 222 fi
 223
 224 mailaddrs="$(config_get owner)" || :
 225 [ -z "$cfg_admin" ] ||
 226 if [ -z "$mailaddrs" ]; then mailaddrs="$cfg_admin"; else mailaddrs="$mailaddrs,$cfg_admin"; fi
 227
 228 # Make sure we don't get any unwanted loose objects
 229 # Starting with Git v2.10.0 fast-import can generate loose objects unless we
 230 # tweak its configuration to prevent that
 231 git_add_config 'fetch.unpackLimit=1'
 232 # Note the git config documentation is wrong
 233 # transfer.unpackLimit, if set, overrides fetch.unpackLimit
 234 git_add_config 'transfer.unpackLimit=1'
 235 # But not the Git v2.10.0 and later fastimport.unpackLimit which improperly uses <= instead of <
 236 git_add_config 'fastimport.unpackLimit=0'
 237
 238 # Initial mirror
 239 echo "Initiating mirroring..."
 240 headref=
 241 showheadwarn=
 242 warnempty=
 243
 244 # remember the starting time so we can easily combine fetched loose objects
 245 # we sleep for 1 second after creating .needspack to make sure all objects are newer
 246 if ! [ -e .needspack ]; then
 247         rm -f .needspack
 248         >.needspack
 249         sleep 1
 250 fi
 251
 252 case "$url" in
 253         svn://* | svn+http://* | svn+https://* | svn+file://* | svn+ssh://*)
 254                 [ -n "$cfg_mirror_svn" ] || { echo "Mirroring svn is disabled" >&2; exit 1; }
 255                 # Allow the username to be specified in the "svn-credential.svn.username"
 256                 # property and the password in the "svn-credential.svn.password" property
 257                 # Use an 'anonsvn' username by default as is commonly used for anonymous svn
 258                 # Default the password to the same as the username
 259                 # The password property will be ignored unless a username has been specified
 260                 if svnuser="$(git config --get svn-credential.svn.username)" && [ -n "$svnuser" ]; then
 261                         if ! svnpass="$(git config --get svn-credential.svn.password)"; then
 262                                 svnpass="$svnuser"
 263                         fi
 264                         url1="${url#*://}"
 265                         url1="${url1%%/*}"
 266                         case "$url1" in ?*"@"?*)
 267                                 urlsch="${url%%://*}"
 268                                 url="$urlsch://${url#*@}"
 269                         esac
 270                 else
 271                         # As a fallback, check in the URL, just in case
 272                         url1="${url#*://}"
 273                         url1="${url1%%/*}"
 274                         svnuser=
 275                         case "$url1" in ?*"@"?*)
 276                                 urlsch="${url%%://*}"
 277                                 url="$urlsch://${url#*@}"
 278                                 url1="${url1%%@*}"
 279                                 svnuser="${url1%%:*}"
 280                                 if [ -n "$svnuser" ]; then
 281                                         svnpass="$svnuser"
 282                                         case "$url1" in *":"*)
 283                                                 svnpass="${url1#*:}"
 284                                         esac
 285                                 fi
 286                         esac
 287                         if [ -z "$svnuser" ]; then
 288                                 svnuser="anonsvn"
 289                                 svnpass="anonsvn"
 290                         fi
 291                 fi
 292                 GIT_ASKPASS_PASSWORD="$svnpass"
 293                 export GIT_ASKPASS_PASSWORD
 294                 # We just remove svn+ here, so svn+http://... becomes http://...
 295                 # We also remove a trailing '/' to match what git-svn will do
 296                 case "$url" in svn+ssh://*) svnurl="$url";; *) svnurl="${url#svn+}";; esac
 297                 svnurl="${svnurl%/}"
 298                 # We require svn info to succeed on the URL otherwise it's
 299                 # simply not a valid URL and without using -s on the init it
 300                 # will not otherwise be tested until the fetch
 301                 svn --non-interactive --username "$svnuser" --password "$svnpass" info "$svnurl" >/dev/null
 302                 # We initially use -s for the init which will possibly shorten
 303                 # the URL.  However, the shortening can fail if a password is
 304                 # not required for the longer version but is for the shorter,
 305                 # so try again without -s if the -s version fails.
 306                 # We must use GIT_DIR=. here or ever so "helpful" git-svn will
 307                 # create a .git subdirectory!
 308                 GIT_DIR=. git svn init --username="$svnuser" --prefix "" -s "$svnurl" <"$mtlinesfile" ||
 309                 GIT_DIR=. git svn init --username="$svnuser" --prefix "" "$svnurl" <"$mtlinesfile"
 310                 # We need to remember this url so we can detect changes because
 311                 # ever so "helpful" git-svn may shorten it!
 312                 config_set svnurl "$svnurl"
 313                 # At this point, since we asked for a standard layout (-s) git-svn
 314                 # may have been "helpful" and adjusted our $svnurl to a prefix and
 315                 # then glued the removed suffix onto the front of any svn-remote.svn.*
 316                 # config items.  We could avoid this by not using the '-s' option
 317                 # but then we might not get all the history.  If, for example, we
 318                 # are cloning an http://svn.example.com/repos/public repository that
 319                 # early in its history moved trunk => public/trunk we would miss that
 320                 # earlier history without allowing the funky shorten+prefix behavior.
 321                 # So we read back the svn-remote.svn.fetch configuration and compute
 322                 # the prefix.  This way we are sure to get the correct prefix.
 323                 gitsvnurl="$(git config --get svn-remote.svn.url)" || :
 324                 gitsvnfetch="$(git config --get-all svn-remote.svn.fetch | tail -1)" || :
 325                 gitsvnprefix="${gitsvnfetch%%:*}"
 326                 gitsvnsuffix="${gitsvnprefix##*/}"
 327                 gitsvnprefix="${gitsvnprefix%$gitsvnsuffix}"
 328                 # Ask git-svn to store everything in the normal non-remote
 329                 # locations being careful to use the correct prefix
 330                 git config --replace-all svn-remote.svn.fetch "${gitsvnprefix}trunk:refs/heads/master"
 331                 git config --replace-all svn-remote.svn.branches "${gitsvnprefix}branches/*:refs/heads/*"
 332                 git config --replace-all svn-remote.svn.tags "${gitsvnprefix}tags/*:refs/tags/*"
 333                 # look for additional non-standard directories to fetch
 334                 # check for standard layout at the same time
 335                 foundstd=
 336                 foundfile=
 337                 svn --non-interactive --username "$svnuser" --password "$svnpass" ls "$gitsvnurl/${gitsvnprefix}" 2>/dev/null |
 338                 { while read file; do case $file in
 339                         # skip the already-handled standard ones and any with a space or tab
 340                         *'      '*|*' '*) :;;
 341                         trunk/|branches/|tags/) foundstd=1;;
 342                         # only fetch extra directories from the $svnurl root (not any files)
 343                         *?/) git config --add svn-remote.svn.fetch \
 344                                 "${gitsvnprefix}${file%/}:refs/heads/${file%/}";;
 345                         *?) foundfile=1;;
 346                 esac; done
 347                 # if files found and no standard directories present use a simpler layout
 348                 if [ -z "$foundstd" ] && [ -n "$foundfile" ]; then
 349                         git config --unset svn-remote.svn.branches
 350                         git config --unset svn-remote.svn.tags
 351                         git config --replace-all svn-remote.svn.fetch ':refs/heads/master'
 352                 fi; }
 353                 test $? -eq 0
 354                 # git svn fetch on a very large repo can take some time and the
 355                 # remote server may interrupt the connection from time to time.
 356                 # keep retrying (after a brief pause) as long as we are making progress.
 357                 # however, we do limit the total number of retries to 1000
 358                 # we will, however, retry up to 5 times even if we're not making progress
 359                 v_get_svn_progress_fingerprint() {
 360                         eval "$1="'"$({ GIT_DIR=. git svn info <"$mtlinesfile" 2>&1; git show-ref --head 2>&1; } |
 361                         git hash-object -t blob --stdin )"' || :
 362                 }
 363                 svn_ret_err() { return "${1:-1}"; }
 364                 svn_retries=1000
 365                 svn_progress=
 366                 v_get_svn_progress_fingerprint svn_progress
 367                 svn_progress_retries="$svn_retries"
 368                 svn_err=0
 369                 while [ "$svn_retries" -gt 0 ]; do
 370                         svn_retries="$(( $svn_retries - 1 ))"
 371                         svn_err=0
 372                         GIROCCO_DIVERT_GIT_SVN_AUTO_GC=1
 373                         export GIROCCO_DIVERT_GIT_SVN_AUTO_GC
 374                         unset GIROCCO_SUPPRESS_AUTO_GC_UPDATE
 375                         saveconfig="$GIT_CONFIG_PARAMETERS"
 376                         git_add_config 'gc.auto=1'
 377                         # Again, be careful to use GIT_DIR=. here or else new .git subdirectory!
 378                         GIT_DIR=. git svn fetch --log-window-size=$var_log_window_size --username="$svnuser" --quiet <"$mtlinesfile" || svn_err="$?"
 379                         GIROCCO_SUPPRESS_AUTO_GC_UPDATE=1
 380                         export GIROCCO_SUPPRESS_AUTO_GC_UPDATE
 381                         unset GIROCCO_DIVERT_GIT_SVN_AUTO_GC
 382                         unset GIT_CONFIG_PARAMETERS
 383                         [ -z "$saveconfig" ] || {
 384                                 GIT_CONFIG_PARAMETERS="$saveconfig"
 385                                 export GIT_CONFIG_PARAMETERS
 386                         }
 387                         [ "${svn_err:-1}" -ne 0 ] || break # success!
 388                         # Check to see if we made any progress
 389                         v_get_svn_progress_fingerprint svn_progress_now
 390                         if [ "$svn_progress_now" != "$svn_progress" ]; then
 391                                 # we made progress, continue the loop
 392                                 svn_progress="$svn_progress_now"
 393                                 svn_progress_retries="$svn_retries"
 394                         else
 395                                 # no progress, but we only give up after
 396                                 # 5 no-progress attempts in a row
 397                                 [ "$(( $svn_progress_retries - $svn_retries ))" -lt 5 ] || break # failure
 398                         fi
 399                         # Pause briefly before retrying to be friendly to the server
 400                         echo 'Pausing for 120 seconds before retrying'
 401                         sleep 120
 402                         cleanup_git_svn_leftovers
 403                         echo 'Retrying fetch'
 404                 done
 405                 [ "${svn_err:-1}" -eq 0 ] || svn_ret_err "$svn_err"
 406                 test ${svn_err:-1} -eq 0
 407                 # git svn does not preserve group permissions in the svn subdirectory
 408                 chmod -R ug+rw,o+r svn
 409                 # git svn also leaves behind ref turds that end with @nnn
 410                 # We get rid of them now
 411                 git for-each-ref --format='%(refname)' |
 412                 LC_ALL=C sed '/^..*@[1-9][0-9]*$/!d; s/^/delete /' |
 413                 git_updateref_stdin
 414                 unset GIT_ASKPASS_PASSWORD
 415                 ;;
 416         darcs://* | darcs+http://* | darcs+https://*)
 417                 [ -n "$cfg_mirror_darcs" ] || { echo "Mirroring darcs is disabled" >&2; exit 1; }
 418                 case "$url" in
 419                         darcs://*) darcsurl="http://${url#darcs://}";;
 420                         *) darcsurl="${url#darcs+}";;
 421                 esac
 422                 git_darcs_fetch "$darcsurl"
 423                 ;;
 424         bzr://*)
 425                 [ -n "$cfg_mirror_bzr" ] || { echo "Mirroring bzr is disabled" >&2; exit 1; }
 426                 # we just remove bzr:// here, a typical bzr url is just
 427                 # "lp:foo"
 428                 bzrurl="${url#bzr://}"
 429                 git_bzr_fetch "$bzrurl"
 430                 ;;
 431         hg+http://* | hg+https://* | hg+file://* | hg+ssh://*)
 432                 [ -n "$cfg_mirror_hg" ] || { echo "Mirroring hg is disabled" >&2; exit 1; }
 433                 # We just remove hg+ here, so hg+http://... becomes http://...
 434                 hgurl="${url#hg+}"
 435                 # Perform the initial hg clone
 436                 hg clone -U "$hgurl" "$(pwd)/repo.hg"
 437                 # Do the fast-export | fast-import
 438                 git_hg_fetch
 439                 ;;
 440         *)
 441                 # We manually add remote.origin.url and remote.origin.fetch
 442                 # to simulate a `git remote add --mirror=fetch` since that's
 443                 # not available until Git 1.7.5 and this way we guarantee we
 444                 # always get exactly the intended configuration and nothing else.
 445                 git config remote.origin.url "$url"
 446                 if ! is_gfi_mirror_url "$url" && [ "$(git config --bool girocco.cleanmirror 2>/dev/null || :)" = "true" ]; then
 447                         git config --replace-all remote.origin.fetch "+refs/heads/*:refs/heads/*"
 448                         git config --add remote.origin.fetch "+refs/tags/*:refs/tags/*"
 449                         git config --add remote.origin.fetch "+refs/notes/*:refs/notes/*"
 450                         git config --add remote.origin.fetch "+refs/top-bases/*:refs/top-bases/*"
 451                         git config --bool girocco.lastupdateclean true
 452                 else
 453                         git config --replace-all remote.origin.fetch "+refs/*:refs/*"
 454                         git config --bool girocco.lastupdateclean false
 455                 fi
 456                 # Set the correct HEAD symref by using ls-remote first
 457                 GIT_SSL_NO_VERIFY=1 GIT_TRACE_PACKET=1 git ls-remote origin >.refs-temp 2>.pkts-temp ||
 458                 {
 459                         # Since everything was redirected, on failure there'd be no output,
 460                         # so let's make some failure output
 461                         cat .pkts-temp
 462                         echo ""
 463                         echo "git ls-remote \"$url\" failed"
 464                         exit 1
 465                 }
 466                 # Compensate for git() {} side effects
 467                 unset GIT_TRACE_PACKET
 468                 # If the server is running at least Git 1.8.4.3 then it will send us the actual
 469                 # symref for HEAD.  If we are running at least Git 1.7.5 then we can snarf that
 470                 # out of the packet trace data.
 471                 if [ -s .refs-temp ]; then
 472                         # Nothing to do unless the remote repository has at least 1 ref
 473                         # See if we got a HEAD ref
 474                         head="$(LC_ALL=C grep -E "^$octet20$hexdig*[ $tab]+HEAD\$" <.refs-temp | LC_ALL=C awk '{print $1}')"
 475                         # If the remote has HEAD set to a symbolic ref that does not exist
 476                         # then we will not receive a HEAD ref in the ls-remote output
 477                         headref=
 478                         showheadwarn=
 479                         symrefcap=
 480                         if [ -n "$head" ]; then
 481                                 symrefcap="$(LC_ALL=C sed -ne <.pkts-temp \
 482                                         "/packet:.*git<.*[ $tab]symref="'HEAD:refs\/heads\/'"[^ $tab]/\
 483                                         {s/^.*[ $tab]symref="'HEAD:\(refs\/heads\/'"[^ $tab][^ $tab]*"'\).*$/\1/;p;}')"
 484                                 # prefer $symrefcap (refs/heads/master if no $symrefcap) if it
 485                                 # matches HEAD otherwise take the first refs/heads/... match
 486                                 matchcnt=0
 487                                 while read ref; do
 488                                         [ -n "$ref" ] || continue
 489                                         matchcnt=$(( $matchcnt + 1 ))
 490                                         if [ -z "$headref" ] || [ "$ref" = "${symrefcap:-refs/heads/master}" ]; then
 491                                                 headref="$ref"
 492                                         fi
 493                                         if [ "$headref" = "${symrefcap:-refs/heads/master}" ] && [ $matchcnt -gt 1 ]; then
 494                                                 break
 495                                         fi
 496                                 done <<-EOT
 497                                 $(LC_ALL=C grep -E "^$head[ $tab]+refs/heads/[^ $tab]+\$" <.refs-temp |
 498                                         LC_ALL=C awk '{print $2}')
 499                                 EOT
 500                                 # Warn if there was more than one match and $symrefcap is empty
 501                                 # or $symrefcap is not the same as $headref since our choice might
 502                                 # differ from the source repository's HEAD
 503                                 if [ $matchcnt -ge 1 ] && [ "$symrefcap" != "$headref" ] &&
 504                                    { [ -n "$symrefcap" ] || [ $matchcnt -gt 1 ]; }; then
 505                                         showheadwarn=1
 506                                 fi
 507                         fi
 508                         if [ -z "$headref" ]; then
 509                                 # If we still don't have a HEAD ref then prefer refs/heads/master
 510                                 # if it exists otherwise take the first refs/heads/...
 511                                 # We do not support having a detached HEAD.
 512                                 # We always warn now because we will be setting HEAD differently
 513                                 # than the source repository had HEAD set
 514                                 showheadwarn=1
 515                                 while read ref; do
 516                                         [ -n "$ref" ] || continue
 517                                         if [ -z "$headref" ] || [ "$ref" = "refs/heads/master" ]; then
 518                                                 headref="$ref"
 519                                         fi
 520                                         [ "$headref" != "refs/heads/master" ] || break
 521                                 done <<-EOT
 522                                 $(LC_ALL=C grep -E "^$octet20$hexdig*[ $tab]+refs/heads/[^ $tab]+\$" <.refs-temp |
 523                                         LC_ALL=C awk '{print $2}')
 524                                 EOT
 525                         fi
 526                         # If we STILL do not have a HEAD ref (perhaps the source repository
 527                         # contains only tags) then use refs/heads/master.  It will be invalid
 528                         # but is no worse than we used to do by default and we'll warn about
 529                         # it.  We do not support a HEAD symref to anything other than refs/heads/...
 530                         [ -n "$headref" ] || headref="refs/heads/master"
 531                         git symbolic-ref HEAD "$headref"
 532                         pruneopt=--prune
 533                         [ "$(git config --bool fetch.prune 2>/dev/null || :)" != "false" ] || pruneopt=
 534                         # remember the starting time so we can easily detect new packs for fast-import mirrors
 535                         # we sleep for 1 second after creating .gfipack to make sure all packs are newer
 536                         if is_gfi_mirror_url "$url" && ! [ -e .gfipack ]; then
 537                                 rm -f .gfipack
 538                                 >.gfipack
 539                                 sleep 1
 540                         fi
 541                         GIT_SSL_NO_VERIFY=1 git remote update $pruneopt
 542                         if [ -e .gfipack ] && is_gfi_mirror_url "$url"; then
 543                                 find -L objects/pack -type f -newer .gfipack -name "pack-$octet20*.pack" -print >>gfi-packs
 544                                 rm -f .gfipack
 545                         fi
 546                 else
 547                         warnempty=1
 548                         git symbolic-ref HEAD "refs/heads/master"
 549                 fi
 550                 rm -f .refs-temp .pkts-temp
 551                 ;;
 552 esac
 553
 554 # The objects subdirectories permissions must be updated now.
 555 # In the case of a dumb http clone, the permissions will not be correct
 556 # (missing group write) despite the core.sharedrepository=1 setting!
 557 # The objects themselves seem to have the correct permissions.
 558 # This problem appears to have been fixed in the most recent git versions.
 559 perms=g+w
 560 [ "$cfg_permission_control" != "Hooks" ] || perms=go+w
 561 chmod $perms $(find -L objects -maxdepth 1 -type d) 2>/dev/null || :
 562
 563 # We may have just cloned a lot of refs and they will all be
 564 # individual files at this point.  Let's pack them now so we
 565 # can have better performance right from the start.
 566 git pack-refs --all
 567
 568 # Initialize gitweb.lastreceive, gitweb.lastchange and info/lastactivity
 569 git config gitweb.lastreceive "$(date '+%a, %d %b %Y %T %z')"
 570 git config gitweb.lastchange "$(date '+%a, %d %b %Y %T %z')"
 571 git for-each-ref --sort=-committerdate --format='%(committerdate:iso8601)' \
 572         --count=1 refs/heads >info/lastactivity || :
 573 ! [ -d htmlcache ] || { >htmlcache/changed; } 2>/dev/null || :
 574
 575 # Don't leave a multi-megabyte useless FETCH_HEAD behind
 576 rm -f FETCH_HEAD
 577
 578 # Last ditch attempt to get a valid HEAD for a non-git source
 579 check_and_set_head || :
 580
 581 # The rest
 582 echo "Final touches..."
 583 git update-server-info
 584 trap "" EXIT
 585
 586 # run gc now unless the clone is empty
 587 if [ -z "$warnempty" ]; then
 588         git config --unset gitweb.lastgc 2>/dev/null || :
 589         rm -f .delaygc .allowgc
 590 fi
 591
 592 emptynote=
 593 [ -z "$warnempty" ] ||
 594 emptynote="
 595 WARNING:  You have mirrored an empty repository.
 596 "
 597 headnote=
 598 [ -z "$showheadwarn" ] || [ -z "$headref" ] ||
 599 headnote="
 600 NOTE:  HEAD has been set to a symbolic ref to \"$headref\".
 601        Use the \"Project settings\" link to choose a different HEAD symref.
 602 "
 603 sizenote=
 604 ! is_gfi_mirror ||
 605 sizenote="
 606 NOTE:  Since this is a mirror of a non-Git source, the initial repository
 607        size may be somewhat larger than necessary.  This will be corrected
 608        shortly.  If you intend to clone this repository you may want to
 609        wait up to 1 hour before doing so in order to receive the more
 610        compact final size.
 611 "
 612 [ -z "$mailaddrs" ] ||
 613 mailref "clone@$cfg_gitweburl/$proj.git" -s "[$cfg_name] $proj clone completed" "$mailaddrs" <<EOT || :
 614 Congratulations! The clone of project $proj just completed.
 615
 616         * Source URL: $url
 617         * GitWeb interface: $cfg_gitweburl/$proj.git
 618         * Project settings: $cfg_webadmurl/editproj.cgi?name=$(echo "$proj" | LC_ALL=C sed -e 's/[+]/%2B/g')
 619 $emptynote$headnote$sizenote
 620 Have a lot of fun.
 621 EOT
 622
 623 echo "Mirroring finished successfuly!"
 624 # In case this is a re-mirror, lastgc could have been set already so clear it now
 625 git config --unset gitweb.lastgc || :
 626 rm .clone_in_progress
 627 echo "$sizenote@OVER@"