3 # NOTE: additional options can be passed to git repack by specifying
4 # them after the project name, for example:
12 echo "Usage: gc.sh projname [extra-repack-args]" >&2
18 unset GIROCCO_SUPPRESS_AUTO_GC_UPDATE
19 .
"$cfg_basedir/jobd/maintain-auto-gc-hack.sh"
20 .
"$cfg_basedir/jobd/generate-auto-gc-update.sh"
21 GIROCCO_SUPPRESS_AUTO_GC_UPDATE
=1 && export GIROCCO_SUPPRESS_AUTO_GC_UPDATE
24 packopts
="--depth=50 --window=50 --window-memory=${var_window_memory:-1g}"
25 quiet
="-q"; [ "${show_progress:-0}" = "0" ] || quiet
=
28 [ "$cfg_permission_control" != "Hooks" ] ||
umask 000
32 eval "$1="'$(( $# - 1 ))'
36 if _result
="$(kill -0 "$1" 2>&1)"; then
37 # process exists and we have permission to signal it
40 case "$_result" in *"not permitted"*)
41 # we do not have permission to signal the process
44 # process does not exist
49 # A .lock file should only exist for much less than a second.
50 # If we see a stale lock file (> 1h old), remove it and then,
51 # just in case, wait 30 seconds for any process whose .lock
52 # we might have just removed (it's racy) to finish doing what
53 # should take much less than a second to do.
54 _stalelock
="$(find -L "$1.lock
" -maxdepth 1 -mmin +60 -print 2>/dev/null)" ||
:
55 if [ -n "$_stalelock" ]; then
60 if (set -C; >"$1.lock") 2>/dev
/null
; then
65 [ "$_try" != "p" ] ||
sleep 1
67 # cannot create lock file
71 # The pre-receive script creates one ref log file per push but we want them to
72 # be coalesced into one ref log file per day. We are guaranteed that any files
73 # we find to coalesce are NOT currently being written to since they are always
74 # written first as temporary files and then moved into place. We attempt to
75 # transfer the most recent modification time to the coalesced log file which
76 # would step on its mod time if it were being written to directly, but if we
77 # find per-process ref log files then it must be a push project and the only
78 # thing that would write directly to the main per-day log file would be a
79 # mirror project so there's actually no conflict.
80 # Also, if the clock is wonky (or was futzed with) we may have both YYYYMMDD
81 # and YYYYMMDD.gz present in which case combine them into YYYYMMDD
83 [ -d reflogs
] ||
return 0
85 find -L reflogs
-maxdepth 1 -type f
-name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]" -print |
86 while read -r rname
; do
87 if [ -e "$rname.gz" ]; then
88 if [ -s "$rname" ]; then
89 # Presumably the .gz file must have been created before the non-gz
90 # file since it had to be uncompressed at some point therefore
91 # we need to append the non-gz contents to it but keep the non-gz
92 # contents timestamp so we rename to YYYYMMDD_ which will sort first
93 # and be picked up in the next step if we are interrupted in the middle.
94 # If a YYYYMMDD_ file already exists we append to it and transfer the
95 # timestamp. Finally we transfer the YYYYMMDD_ timestamp to the result
96 # and remove the YYYYMMDD_ temporary file leaving the result uncompressed.
97 if [ -e "${rname}_" ]; then
98 cat "$rname" >>"${rname}_"
99 touch -r "$rname" "${rname}_"
103 mv "$rname" "${rname}_"
105 gzip -d "$rname.gz" </dev
/null
106 [ -e "$rname" ] && ! [ -e "$rname.gz" ]
107 cat "${rname}_" >>"$rname"
108 touch -r "${rname}_" "$rname"
111 # Just remove the empty file to resolve the problem
116 find -L reflogs
-maxdepth 1 -type f
-name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]_*" -print | LC_ALL
=C
sort |
117 while read -r rname
; do
118 logname
="${rname%%_*}"
119 # If someone's been futzing with the date, the file we want to
120 # append to could already have been compressed, so we just uncompress
121 # it here. The previous block guarantees we do not have both a compressed
122 # and uncompressed version present at the same time.
123 if [ -e "$logname.gz" ]; then
124 gzip -d "$logname.gz" </dev
/null
125 [ -e "$logname" ] && ! [ -e "$logname.gz" ]
127 cat "$rname" >>"$logname"
128 touch -r "$rname" "$logname"
130 if [ -e "$rname" ]; then
132 echo "! [$proj] failed to remove $rname" >&2
133 exit 1 # will only exit subshell created by "|"
139 # Remove any files in reflogs that are older than $cfg_reflogs_lifetime days
141 [ -d reflogs
] ||
return 0
142 exp
="$(( ${cfg_reflogs_lifetime:-1} * 1440 ))"
143 [ $exp -gt 0 ] || exp
=1440
144 [ $exp -le 43200 ] || exp
=43200
145 find -L reflogs
-maxdepth 1 -type f
-mmin "+$exp" -exec rm -f '{}' + ||
:
148 # Compact any reflogs that are not today's UTC date unless a .gz version exists
150 [ -d reflogs
] ||
return 0
151 _td
="reflogs/$(TZ=UTC date '+%Y%m%d')"
152 find -L reflogs
-maxdepth 1 -type f
-name "[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]" -print |
153 while read -r rname
; do
154 [ "$rname" != "$_td" ] ||
continue
155 ! [ -e "$rname.gz" ] ||
continue
156 gzip -9 "$rname" </dev
/null
160 # return true if there's more than one objects/pack-<sha>.pack file or
161 # ANY sha-1 files in objects or
162 # there's one pack and it's not a normal pack name or
163 # there's one pack but not any refs
165 _packs
="$(find -L objects/pack -name "pre-auto-gc-
[12].pack
" -prune -o -name "*.pack
" -type f -print 2>/dev/null | head -n 2)"
166 vcnt _packscnt
$_packs
167 if [ $_packscnt -gt 1 ]; then
170 if [ $_packscnt -eq 1 ]; then
171 # the single pack name is in $_packs
172 _packs
="${_packs%.pack}"
173 _packs
="${_packs#objects/pack/}"
176 _packs
="${_packs#pack-}"
177 if [ "${#_packs}" -lt 40 ] ||
[ "${_packs#*[!0-9a-fA-F]}" != "$_packs" ]; then
178 # name not exclusively 40 or more hexadecimal digits makes it dirty
183 # abnormal name makes it dirty
188 _objs
=$
(find -L objects
/$octet -name "$octet19*" -type f
-print 2>/dev
/null |
head -n 1 | LC_ALL
=C
wc -l)
189 [ $_objs -eq 0 ] ||
return 0
190 [ $_packscnt -eq 1 ] ||
return 1
191 # we do this check last because it's potentially the most expensive;
192 # at this point we know we do not have any loose objects, but we do
193 # have one pack that's named "normally"; empty refs => dirty
197 # make sure combine-packs uses the correct Git executable
198 run_combine_packs
() {
199 PATH
="$var_git_exec_path:$cfg_basedir/bin:$PATH" @basedir@
/jobd
/combine-packs.sh
"$@"
202 # duplicate the first file to the name given by the second file making sure that
203 # the second file appears atomically all-at-once after the copy has been completed
204 # and does not appear at all if the copy fails (in which case this function fails)
205 # if the second file already exists this function fails with status 1
206 # if the file names are the same this function returns immediately with success
208 [ "$1" != "$2" ] ||
return 0
209 ! [ -e "$2" ] ||
return 1
211 *?
/?
*) _tmpdir
="${2%/*}";;
214 _tmpfile
="$(mktemp "${_tmpdir:-.}/packtmp-XXXXXX
")" ||
return 1
215 cp -fp "$1" "$_tmpfile" ||
return 1
216 mv -f "$_tmpfile" "$2"
219 # rename_pack oldnamepath newnamepath
220 # note that .keep and .bndl files are left untouched and not moved at all!
222 [ $# -eq 2 ] && [ "$1" != "$2" ] ||
{
223 echo >&2 "[$proj] incorrect use of rename_pack function"
226 # Git assumes that if the destination of the rename already exists
227 # that it is, in fact, a copy of the same bytes so silently succeeds
228 # without doing anything. We duplicate that logic here.
229 # Git checks for the .idx file first before even trying to use a pack
230 # so it should be the last moved and the first removed.
231 for ext
in pack bitmap idx
; do
232 [ -f "$1.$ext" ] ||
continue
233 ln "$1.$ext" "$2.$ext" >/dev
/null
2>&1 ||
234 dupe_file
"$1.$ext" "$2.$ext" >/dev
/null
2>&1 ||
235 [ -f "$2.$ext" ] ||
{
236 echo >&2 "[$proj] unable to move $1.$ext to $2.$ext"
240 for ext
in idx pack bitmap
; do
246 # combine the input pack(s) into a new pack (or possibly packs if packSizeLimit set)
247 # input pack names are read from standard input one per line delimited by the first
248 # ':', ' ' or '\n' character on the line (which allows gfi-packs to be read directly)
249 # all arguments, if any, are passed to pack-objects as additional options
250 # returns non-zero on failure AND creates .gc_failed in that case
253 find -L objects
/pack
-maxdepth 1 -type f
-name '*.zap*' -exec rm -f '{}' + ||
:
254 run_combine_packs
--replace "$@" $packopts --all-progress-implied $quiet --non-empty ||
{
261 # if the current directory is_gfi_mirror then repack all packs listed in gfi-packs
263 [ -n "$gfi_mirror" ] ||
return 0
264 [ -d objects
/pack
] ||
{ rm -f gfi-packs
; return 0; }
265 progress
"~ [$proj] redeltifying poor quality git fast-import packs"
266 combine_packs
--ignore-missing --no-reuse-delta <gfi-packs
271 # see if there are "lotsa" loose objects
272 # "lotsa" is defined as the 17, 68, 71 and 86 object directories existing
273 # and there being at least 5 total objects between them which corresponds
274 # to an approximate average of 320 loose objects before this function starts
275 # returning true and triggering a "mini" gc to pack up loose objects
276 lotsa_loose_objects
() {
277 [ -d objects
/17 ] && [ -d objects
/68 ] && [ -d objects
/71 ] && [ -d objects
/86 ] ||
return 1
278 _objs
=$
(( $
(find -L objects
/17 objects
/68 objects
/71 objects
/86 -maxdepth 1 -name "$octet19*" -type f
-print 2>/dev
/null | LC_ALL
=C
wc -l) ))
279 [ ${_objs:-0} -ge 5 ]
282 # pack any existing loose objects into a new _l.pack file then run prune-packed
283 # note that prune-packed is NOT run beforehand -- the caller must do that if needed
284 # loose objects need not be part of complete commits/trees as --weak-naming is used
285 pack_loose_objects
() {
286 _lpacks
="$(run_combine_packs </dev/null --names --loose --weak-naming --non-empty --all-progress-implied ${quiet:---progress} $packopts)"
287 if [ -n "$_lpacks" ]; then
288 # We need to identify these packs later so we don't combine_packs them
289 for _objpack
in $_lpacks; do
290 rename_pack
"objects/pack/pack-$_objpack" "objects/pack/pack-${_objpack}_l" ||
:
292 git prune-packed
$quiet
296 # combine small packs into larger pack(s)
297 # we avoid any _[lo], keep, bndl or bitmap packs
298 # if the optional argument is non-empty even a single small pack will be redeltad
299 combine_small_packs
() {
302 if [ -n "$1" ] && [ -n "$noreusedeltaopt" ]; then
305 _lpo
="--exclude-no-idx --exclude-keep --exclude-bitmap --exclude-bndl"
306 _lpo
="$_lpo --exclude-sfx _u --exclude-sfx _o --exclude-sfx _l"
307 _lpo
="$_lpo --quiet --object-limit $var_redelta_threshold objects/pack"
309 _cnt
="$(list_packs --count $_lpo)" ||
:
310 test "${_cnt:-0}" -ge $_minsmallpacks
312 [ -n "$_didprogress" ] ||
{
313 progress
"~ [$proj] combining small packs into a single larger pack"
316 _newp
="$(list_packs $_lpo | combine_packs --names $noreusedeltaopt)"
318 # be paranoid and exit the loop if we haven't reduced the number of packs
319 [ $_newc -lt $_cnt ] ||
break
325 # combine small _l packs into larger pack(s) using --weak-naming
326 # we avoid any non _l, keep, bndl or bitmap packs
327 # if the optional 2nd argument is non-empty even a single small pack will be redeltad
328 combine_small_loose_packs
() {
331 if [ -n "$1" ] && [ -n "$noreusedeltaopt" ]; then
334 _lpo
="--exclude-no-idx --exclude-keep --exclude-bitmap --exclude-bndl"
335 _lpo
="$_lpo --exclude-no-sfx _l"
336 _lpo
="$_lpo --quiet --object-limit $var_redelta_threshold objects/pack"
338 _cnt
="$(list_packs --count $_lpo)" ||
:
339 test "${_cnt:-0}" -ge $_minsmallpacks
341 [ -n "$_didprogress" ] ||
{
342 progress
"~ [$proj] combining small loose packs into a single larger pack"
345 _newp
="$(list_packs $_lpo | combine_packs --names --weak-naming $noreusedeltaopt)"
346 # We need to identify these packs later so we don't combine_packs them
347 for _objpack
in $_newp; do
348 rename_pack
"objects/pack/pack-$_objpack" "objects/pack/pack-${_objpack}_l" ||
:
351 # be paranoid and exit the loop if we haven't reduced the number of packs
352 [ $_newc -lt $_cnt ] ||
break
358 # Unfortunately, some fetch strategies (e.g. git-svn and non-smart HTTP) lack
359 # the ability to store newly fetched objects in a pack.
360 # However, the fetch code conveniently sets .needspack just before it fetches
361 # so that it's easy to find all the loose objects that have been fetched and
362 # combine them into a pack. The --no-reuse-delta option is meaningless here
363 # since everything to be packed is a loose object and therefore not a delta so
364 # deltification will always take place.
366 [ -f .needspack
] ||
return 0
368 mv -f .needspack .needspackgc
369 progress
"~ [$proj] combining fetched loose objects into a pack"
370 _newp
="$(find -L objects/$octet -maxdepth 1 -type f -newer .needspackgc -name "$octet19*" -print 2>/dev/null |
371 LC_ALL=C awk -F / '{print $2 $3}' |
372 run_combine_packs --objects --names $packopts --incremental --all-progress-implied $quiet --non-empty)" ||
{
373 # We used to fail gc here.
374 # Now, however, we just ignore the failure because we have
375 # another mechanism to handle loose objects and it's possible
376 # that the fetcher somehow brought in unconnected objects which
377 # would cause the above combine-packs to fail.
378 # By ignoring the failure and just removing the .needspack file
379 # the loose objects will be treated as "ordinary" loose objects
380 # and packed using the "--weak-naming" option which can handle
381 # broken connectivity.
382 # That's a better solution than just failing here or leaving
383 # .needspack behind to potentially continue to fail again and
387 if [ -n "$_newp" ]; then
388 # remove the now-redundant loose objects -- this is always safe
389 # even during a concurrent push because a reprepare_packed_git
390 # will be triggered if an object that should be there is not
391 # found thereby finding it in the new pack instead
392 git prune-packed
$quiet
397 # HEADSHA="$(pack_is_complete /full/path/to/some.pack /full/path/to/packed-refs "$(cat HEAD)")"
399 # Must have a matching .idx file and a non-empty packed-refs file
400 [ -s "${1%.pack}.idx" ] ||
return 1
401 [ -s "$2" ] ||
return 1
407 "ref: refs/"?
*|
"ref:refs/"?
*|
"refs/"?
*)
408 _headmatch
="${3#ref:}"
409 _headmatch
="${_headmatch# }"
410 _headmatchpat
="$(echo "$_headmatch" | LC_ALL=C sed -e 's/\([.$]\)/\\\1/g')"
411 _headsha
="$(LC_ALL=C grep -e "^
$octet20$hexdig* $_headmatchpat\$
" <"$2" |
412 LC_ALL=C cut -d ' ' -f 1)"
413 case "$_headsha" in $octet20*) :;; *)
421 rm -rf pack_is_complete_test
422 mkdir pack_is_complete_test
423 mkdir pack_is_complete_test
/refs
424 mkdir pack_is_complete_test
/objects
425 mkdir pack_is_complete_test
/objects
/pack
426 echo "$_headsha" >pack_is_complete_test
/HEAD
427 ln -s "$1" pack_is_complete_test
/objects
/pack
/
428 ln -s "${1%.pack}.idx" pack_is_complete_test
/objects
/pack
/
429 ln -s "$2" pack_is_complete_test
/packed-refs
430 _count
="$(git --git-dir=pack_is_complete_test rev-list --count --all 2>/dev/null)" ||
:
431 rm -rf pack_is_complete_test
432 [ -n "$_count" ] ||
return 1
433 [ "$_count" -gt 0 ] 2>/dev
/null ||
return 1
437 # On return a "$lockf" will have been created that must be removed when gc is done
439 # be compatibile with gc.pid file from newer Git releases
443 if [ "$(createlock "$lockf")" ]; then
445 # 1) less than 12 hours old
446 # 2) contains two fields (pid hostname) NO trailing NL
447 # 3) the hostname is different OR the pid is still alive
448 # then we exit as another active process is holding the lock
449 if [ "$(find -L "$lockf" -maxdepth 1 -mmin -720 -print 2>/dev/null)" ]; then
452 read -r apid ahost ajunk
<"$lockf" ||
:
453 if [ "$apid" ] && [ "$ahost" ]; then
454 if [ "$ahost" != "$hn" ] || pidactive
"$apid"; then
460 echo >&2 "[$proj] unable to create gc.pid.lock file"
463 if [ -n "$active" ]; then
465 echo >&2 "[$proj] gc already running on machine '$ahost' pid '$apid'"
468 printf "%s %s" "$$" "$hn" >"$lockf.lock"
469 chmod 0664 "$lockf.lock"
470 mv -f "$lockf.lock" "$lockf"
473 # Create a repack subdirectory such that running repack in it will pack the
474 # same things that a pack in the normal directory would except that the pack
475 # is guaranteed to be generated in an optimized order by adding a suitable
476 # synthesized ref in the refs/tags namespace (yes, pack-objects.c really does
477 # behave differently depending on the contents of the refs/tags namespace).
478 # Before calling this, pack-refs --all MUST be performed or the wrong pack
479 # will end up being made.
481 # If a ref deletion is pushed after making the repack subdir but before the
482 # the actual repack, the discarded objects will be packed -- no big deal,
483 # they'll get discarded the next time gc runs.
485 # If a fast-forward ref update is pushed after making the repack subdir but
486 # before the actual repack, it will be picked up and the new objects packed
487 # (subject to the normal git repack race about picking such updates up).
489 # If a non-fast-forward ref update is pushed after making the repack subdir but
490 # before the actual repack, it will be picked up like a fast-forward update but
491 # the discarded objects will be included like a ref deletion (until the next
492 # scheduled gc takes place).
494 # We retain a copy of the original packed-refs file as repack/packed-refs.orig
495 # If ref deletions come in while we're repacking, the original packed-refs
496 # file will be modified, but we'll still pack the deleted ref(s).
497 # If the packed-refs.orig file is used to create the bundle header we avoid
498 # a situation where the bundle contains a ref state that never actually
499 # existed in reality (for example a new branch is pushed and then an old
500 # branch deleted afterwards -- the deletion would show up in the bundle
501 # because it will cause the original packed-refs file to be re-written, but
502 # the new branch creation will not unless we do another pack-refs which might
503 # lead to having in incomplete bundle). Therefore we want to keep a copy of
504 # the original packed-refs file around. We do the same thing for HEAD.
506 # It's possible that the "objects" subdirectory is a symbolic link.
507 # Git does support this. However, during the repacking process, new packs
508 # will be created in repack/alt/pack and then moved into objects/pack.
509 # In order for this to work seemlessly, they must both be on the same
510 # filesystem. But when objects (or even objects/pack) is a symbolic link they
511 # might not be. For this reason a "repack" subdirectory is created under
512 # objects/pack and the repack/alt/pack directory symbolicly linked to it.
514 # Git allows not just HEAD to be a symbolic-ref, but any ref anywhere in the
515 # refs namespace. We are concerned about ref name collisions and getting the
516 # right tag set to get an optimal pack. We can safely duplicate the ref space
517 # under refs/heads, refs/notes and refs/remotes without any risk of unwanted
518 # collisions and this will likely make over 99%+ of all symbolic refs found
519 # in the wild work properly. Girocco itself never creates any symbolic refs
520 # inside the refs namespace; this is a nod to simultaneously using a Girocco
521 # repository for other purposes.
523 ! [ -d repack
] ||
rm -rf repack
524 ! [ -d repack
] ||
{ echo >&2 "[$proj] cannot remove repack subdirectory"; exit 1; }
525 [ -d objects
/pack
] || mkdir
-p objects
/pack
526 ! [ -d objects
/pack
/repack
] ||
rm -rf objects
/pack
/repack
527 ! [ -d objects
/pack
/repack
] ||
{ echo >&2 "[$proj] cannot remove objects/pack/repack subdirectory"; exit 1; }
528 mkdir repack repack
/refs repack
/alt objects
/pack
/repack
529 [ -d info
] || mkdir info
530 ln -s ..
/config repack
/config
531 ln -s ..
/info repack
/info
532 ln -s ..
/objects repack
/objects
533 ln -s "$PWD/objects/pack/repack" repack
/alt
/pack
534 ln -s ..
/..
/refs repack
/refs
/refs
535 ! [ -d logs
] ||
ln -s ..
/logs repack
/logs
536 ! [ -d worktrees
] ||
ln -s ..
/worktrees repack
/worktrees
537 _lines
=$
(( $
(LC_ALL
=C
wc -l <packed-refs
) ))
538 cat HEAD
>repack
/HEAD.orig
539 >repack
/packed-refs.extra
541 cat packed-refs
>repack
/packed-refs.orig
542 if [ $
(LC_ALL
=C
wc -l <repack
/packed-refs.orig
) -ne "$_lines" ]; then
543 echo >&2 "[$proj] error: make_repack_dir failed original packed-refs line count sanity check"
546 if [ "${cfg_fetch_stash_refs:-0}" = "0" ]; then
547 # migrate any refs/stash or refs/tgstash lines to repack/packed-refs.extra
548 <repack
/packed-refs.orig
awk -v xtra
="repack/packed-refs.extra" '
549 BEGIN { peeling = 0 }
550 NR == 1 && /^#/ { print; next; }
551 peeling && /^\^/ { print >>xtra; next; }
552 /^[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]+ refs\/(stash|tgstash)(\/|$)/ {
557 { peeling = 0; print; }
558 ' >repack
/packed-refs.new
559 _xtralines
="$(( $(LC_ALL=C wc -l <repack/packed-refs.extra) + 0 ))"
560 _newlines
="$(( $(LC_ALL=C wc -l <repack/packed-refs.new) + 0 ))"
561 if [ "$(( $_newlines + $_xtralines ))" -ne "$_lines" ]; then
562 echo >&2 "[$proj] error: make_repack_dir failed packed-refs.extra line count sanity check"
565 mv -f repack
/packed-refs.new repack
/packed-refs.orig
568 # Note: Git v1.5.0 introduced the "# pack-refs with:" header line for the packed-refs file
569 sed '/^# pack-refs/d; s, refs/, refs/!/,' <repack
/packed-refs.orig
>repack
/packed-refs
571 headref
="$(git rev-parse --verify --quiet HEAD)" ||
:
572 if [ -n "$headref" ]; then
573 echo "$headref refs/!=/HEAD" >>repack
/packed-refs
574 echo "$headref refs/heads/!" >>repack
/packed-refs
575 nohead
='\, refs/heads/!$,d; '
576 _lines
=$
(( $_lines + 2 ))
578 if [ $
(( $
(LC_ALL
=C
wc -l <repack
/packed-refs
) + 1 )) -ne "$_lines" ]; then
579 echo >&2 "[$proj] error: make_repack_dir failed packed-refs initial line count sanity check"
582 sed -n "$nohead"'\, refs/heads/,p; \, refs/notes/,p; \, refs/remotes/,p' <repack
/packed-refs.orig
>>repack
/packed-refs
583 _newlines
="$(( $(LC_ALL=C wc -l <repack/packed-refs) ))"
584 if [ $
(( $_newlines + 1 )) -lt "$_lines" ]; then
585 echo >&2 "[$proj] error: make_repack_dir failed packed-refs extra line count sanity check"
589 optref
="$(git rev-list -n 1 --all 2>/dev/null)" ||
:
590 if [ -n "$optref" ]; then
591 echo "$optref refs/tags/!" >>repack
/packed-refs
592 _lines
=$
(( $_lines + 1 ))
593 echo "$optref" >repack
/HEAD
595 cat HEAD
>repack
/HEAD
597 if [ $
(LC_ALL
=C
wc -l <repack
/packed-refs
) -ne "$_lines" ]; then
598 echo >&2 "[$proj] error: make_repack_dir failed packed-refs line count sanity check"
603 # Remove any crud that's been left behind by interrupted operations
604 # that did not clean up after themselves
606 # Remove any existing FETCH_HEAD
607 # There can only be a FETCH_HEAD if we've been fetching, not if we've been
608 # receiving pushes (those never create a FETCH_HEAD).
609 # And if we're fetching because we're a mirror, we know we're not fetching right
610 # now since jobd.pl never runs a project's fetch simultaneously with its gc.
611 # Therefore any existing FETCH_HEAD is junk. And it may be many megabytes if
612 # there were a lot of refs.
615 # remove any existing pack_is_complete_test or repack subdirectories
616 # If either exists when this function is called it's crud
617 rm -rf pack_is_complete_test repack objects
/pack
/repack
619 # Remove any stale pack remnants that are more than an hour old.
620 # Stale pack fragments are defined as any pack-<sha1>.ext where .ext is NOT
621 # .pack AND the corresponding .pack DOES NOT exist. A bunch of stale
622 # pack-<sha1>.idx files without their corresponding .pack files are worthless
623 # and just waste space. Normally there shouldn't be any remnants but actually
624 # this can happen when things are interrupted at just the wrong time.
625 # Note that the objects/pack directory is created by git init and should
627 find -L objects
/pack
-maxdepth 1 -type f
-mmin +60 -name "pack-$octet20*.?*" -print |
628 LC_ALL
=C
sed -e 's/^objects\/pack\/pack-//; s/\..*$//' | LC_ALL
=C
sort -u |
629 while read packsha
; do
630 ! [ -e "objects/pack/pack-$packsha.pack" ] ||
continue
631 rm -f "objects/pack/pack-$packsha".?
*
634 # Remove any stale tmp reflogs files that are more than one hour old.
635 # Since they are created only while the pre-receive hook is running and
636 # all it does is process a bunch of refs passed to it on standard input
637 # it's inconceivable that it would ever take as much as an hour to run.
638 if [ -d reflogs
]; then
639 find -L reflogs
-maxdepth 1 -type f
-mmin +60 -name "tmp_*" -exec rm -f '{}' + ||
:
642 # Remove any stale object tmp_obj_* files that are more than 3 hours old.
643 # Really these files should only exist very briefly so there shouldn't be any
644 # but things happen that can end up leaving them behind.
645 find -L objects
/$octet -maxdepth 1 -type f
-mmin +180 -name "tmp_obj_?*" -exec rm -f '{}' + 2>/dev
/null ||
:
647 # Remove any stale pack .keep files that are more than 12 hours old.
648 # We don't do anything to create any permanent pack .keep files, so they must
649 # be remnants from some failed push or something. Removing the .keep will
650 # allow the pack to be properly repacked.
651 find -L objects
/pack
-maxdepth 1 -type f
-mmin +720 -name "pack-$octet20*.keep" -exec rm -f '{}' + ||
:
653 # Remove any stale tmp_pack_*, tmp_idx_*, tmp_bitmap_*, packtmp-* or .tmp-*-pack* files
654 # that are more than 12 hours old.
655 find -L objects
/pack
-maxdepth 1 -type f
-mmin +720 \
( \
656 -name "tmp_pack_?*" -o -name "tmp_idx_?*" -o -name "tmp_bitmap_?*" -o \
657 -name "packtmp-?*" -o -name ".tmp-?*-pack*" \
658 \
) -exec rm -f '{}' + ||
:
660 # Remove any stale incoming-* object quarantine directories that are
661 # more than 12 hours old. These are new with Git >= 2.11.0.
662 find -L objects
-maxdepth 1 -type d
-name 'incoming-?*' -mmin +720 \
663 -exec rm -rf '{}' + ||
:
665 # Remove any stale shallow_* files that are more than 12 hours old.
666 # These can be left behind by Git >= 1.8.4.2 and < 2.0.0 when a client
667 # requests a shallow clone. Also discard stale .refs-temp* and
668 # .refs-new* files at the same time.
669 find -L .
-maxdepth 1 -type f
-mmin +720 \
( \
670 -name "shallow_?*" -o -name ".refs-temp*" -o -name ".refs-new*" \
671 \
) -exec rm -f '{}' + ||
:
673 # Remove any stale *.temp files in the objects area that are more than 12 hours old.
674 # This can be stale sha1.temp, or stale *.pack.temp so we kill all stale *.temp.
675 find -L objects
-type f
-mmin +720 -name "*.temp" -exec rm -f '{}' + ||
:
677 # Remove any stale *.lock files in the htmlcache area that might have been left
678 # behind after an abnormal exit during an attempt to update a cached file and
679 # are more than 1 hour old.
680 ! [ -d htmlcache
] ||
find -L htmlcache
-type f
-mmin +60 -name "*.lock" -exec rm -f '{}' + ||
:
682 # Remove any stale git-svn temp files that are more than 12 hours old.
683 # The git-svn process creates temp files with random 10 character names
684 # in the root of $GIT_DIR. Unfortunately they do not have a recognizable
685 # prefix, so we just have to kill any files with a 10-character name. We
686 # do this only for git-svn mirrors. All characters are chosen from
687 # [A-Za-z0-9_] so we can at least check that and fortunately the only
688 # collision is 'FETCH_HEAD' but that shouldn't matter.
689 # There may also be temp files with a Git_ prefix as well.
690 if [ -n "$svn_mirror" ]; then
691 _randchar
='[A-Za-z0-9_]'
692 _randchar2
="$_randchar$_randchar"
693 _randchar4
="$_randchar2$_randchar2"
694 _randchar10
="$_randchar4$_randchar4$_randchar2"
695 find -L .
-maxdepth 1 -type f
-mmin +720 -name "$_randchar10" -exec rm -f '{}' + ||
:
696 find -L .
-maxdepth 1 -type f
-mmin +720 -name "Git_*" -exec rm -f '{}' + ||
:
699 # Remove any stale fast_import_crash_<pid> files that are more than 3 days old.
700 if [ -n "$gfi_mirror" ]; then
701 find -L .
-maxdepth 1 -type f
-mmin +4320 -name "fast_import_crash_?*" -exec rm -f '{}' + ||
:
704 # Remove any stale core or *.core or core.* files that are more than 3 days old.
705 find -L .
-maxdepth 1 -type f
-mmin +4320 \
( -name "core" -o -name "*.core" -o -name "core.*" \
) \
706 -exec rm -f '{}' + ||
:
710 ## Garbage Collection Types
712 ## There are two kinds of possible garbage collection (gc) operations:
714 ## 1. A normal, full gc
717 ## If the full garbage collection interval has expired (or gc has never been
718 ## run), then a normal, full gc will take place. Otherwise, a "mini" gc will
719 ## take place if the file .needsgc exists.
721 ## A "mini" gc is similar to "git gc --auto" in that it may not end up actually
722 ## doing anything unless the right conditions are present so it's not a burden
723 ## to run it often. If the file .needsgc exists, a "mini" gc will occur at
724 ## the next opportunity.
726 ## See the docs/technical/gc.txt and docs/technical/gc-mini.txt files for more
727 ## of the gory details of how garbage collection is performed.
729 ## Note, however, that the .nogc file suppresses ALL gc activity (normal or mini).
734 cd "$cfg_reporoot/$proj.git"
735 [ -d objects
/pack
] ||
{ rm -f gfi-packs
; mkdir
-p objects
/pack
; }
736 mirror_url
="$(get_mirror_url)" ||
:
738 ! is_svn_mirror_url
"$mirror_url" || svn_mirror
=1
740 if [ -f gfi-packs
] && [ -s gfi-packs
] && is_gfi_mirror_url
"$mirror_url"; then
744 # If git config --bool --get girocco.redelta is explicitly false then automatic
745 # redelta when there are less than $var_redelta_threshold objects will be suppressed.
746 # On the other hand, if git config --get girocco.redelta is "always" then, on a full
747 # gc only, for the final repack, deltas will always be recomputed.
748 # This can be set on a per-project basis to avoid unusual pathological gc behavior.
749 # Setting this will hurt efficiency of the affected repository.
750 # Note that fast-import packs ALWAYS get new deltas regardless of this setting.
751 noreusedeltaopt
="--no-reuse-delta"
752 [ "$(git config --bool --get girocco.redelta 2>/dev/null || :)" != "false" ] || noreusedeltaopt
=
754 [ "$(git config --get girocco.redelta 2>/dev/null || :)" != "always" ] || alwaysredelta
=1
756 # Extract any -f or -F or --no-reuse-object or --no-reuse-delta options
757 # to be compatible with the old and new gc.sh versions and avoid ugly argument
758 # duplication in process lists at the same time
759 # Any options found will override the "girocco.redelta" setting
762 while [ $idx -gt 0 ]; do
771 -F|
--no-reuse-object)
779 printf >&2 '%s\n' "bad non-option argument: $opt"
780 echo >&2 "(Did you perhaps intend to use a --xxx=yyy form?)"
783 [ -z "$opt" ] ||
set -- "$@" "$opt"
785 if [ -n "$alwaysredelta" ]; then
786 noreusedeltaopt
="--no-reuse-delta"
787 [ -z "$recompress" ] || noreusedeltaopt
="--no-reuse-object"
790 trap 'e=$?; rm -f .gc_in_progress; if [ $e != 0 ]; then echo "gc failed dir: $PWD" >&2; fi' EXIT
794 # date -R is linux-only, POSIX equivalent is '+%a, %d %b %Y %T %z'
795 datefmt
='+%a, %d %b %Y %T %z'
798 if [ "${force_gc:-0}" = "0" ] && check_interval lastgc
$cfg_min_gc_interval; then
799 if [ -e .needsgc
]; then
802 progress
"= [$proj] garbage check skip (last at $(config_get lastgc))"
806 if [ -e .nogc
]; then
807 progress
"x [$proj] garbage check disabled"
810 if ! [ -e .nofetch
] && [ -e .clone_in_progress
] && ! [ -e .clone_failed
]; then
811 progress
"x [$proj] garbage check disabled (clone in progress)"
814 if [ -z "$isminigc" ] && [ -e .delaygc
] && [ -e .needsgc
]; then
815 # Eligible for a full gc but .delaygc is set so it would be skipped
816 # However .needsgc is also set so transform it into a mini instead
818 progress
"~ [$proj] garbage check delayed but checking mini because .needsgc"
821 if [ -n "$isminigc" ]; then
822 # Perform a "mini" gc
823 # Note that .delaygc is ignored here as that's only intended for full gc
825 rm -f .allowgc .needsgc
826 rm -f objects
/pack
/pack-
*_
[rful
].keep
831 maintain_auto_gc_hack
832 generate_auto_gc_update
834 if [ -f .needspack
]; then
836 progress
"+ [$proj] mini garbage check ($(date))"
839 if [ -z "$cfg_delay_gfi_redelta" ] && [ -n "$gfi_mirror" ]; then
840 # $Girocco::Config::delay_gfi_redelta is false, force redeltification now
841 if [ -z "$miniactive" ]; then
843 progress
"+ [$proj] mini garbage check ($(date))"
847 if lotsa_loose_objects
; then
848 if [ -z "$miniactive" ]; then
850 progress
"+ [$proj] mini garbage check ($(date))"
854 # If there aren't at least 10 non-keep, non-bitmap, non-bndl packs then
855 # don't actually process them yet
856 lpo
="--exclude-no-idx --exclude-keep --exclude-bitmap --exclude-bndl --quiet"
857 packcnt
="$(list_packs --count $lpo objects/pack)" ||
:
858 if [ "${packcnt:-0}" -ge 10 ]; then
859 if [ -z "$miniactive" ]; then
861 progress
"+ [$proj] mini garbage check ($(date))"
863 # if we have at least 10 packs go ahead and pack all refs now too
864 git pack-refs
--all --prune
865 if [ -n "$gfi_mirror" ]; then
867 packcnt
="$(list_packs --count $lpo objects/pack)" ||
:
869 # if repack_gfi_packs dropped the pack count to < 10 don't combine
870 if [ "${packcnt:-0}" -ge 10 ]; then
872 combine_small_loose_packs
873 packcnt
="$(list_packs --count $lpo objects/pack)" ||
:
875 # if we still have more than 10 packs trigger a full gc
876 if [ "${packcnt:-0}" -ge 10 ]; then
877 # We shouldn't be in a .delaygc state at this point, but if
878 # we are then nuke it because we really need a full gc now
880 git config
--unset gitweb.lastgc
882 git update-server-info
# just in case
883 progress
"- [$proj] mini garbage check triggering full gc too many packs ($(date))"
888 if [ -n "$miniactive" ]; then
889 git update-server-info
890 progress
"- [$proj] mini garbage check ($(date))"
892 progress
"= [$proj] mini garbage check nothing but crud removal to do ($(date))"
897 # Avoid unnecessary garbage collections:
898 # 1. If lastreceive is set and is older than lastgc
900 # 2. We are not a fork (! -s alternates) -OR- lastparentgc is older than lastgc
902 # If lastgc is NOT set or lastreceive is NOT set we MUST run gc
903 # If we are a fork and lastparentgc is NOT set we MUST run gc
905 # If the repo is dirty after removing any crud we MUST run gc
907 gcstart
="$(date "$datefmt")"
910 ! [ -s objects
/info
/alternates
] || isfork
=1
912 [ -z "$isfork" ] || lastparentgcsecs
="$(config_get_date_seconds lastparentgc)" ||
:
914 if lastreceivesecs
="$(config_get_date_seconds lastreceive)" &&
915 [ "${force_gc:-0}" = "0" ] &&
916 lastgcsecs
="$(config_get_date_seconds lastgc)" &&
917 [ $lastreceivesecs -lt $lastgcsecs ]; then
918 # We've run gc since we last received, so maybe we can skip,
919 # check if not fork or fork and lastparentgc < lastgc
920 if [ -n "$isfork" ]; then
921 if [ -n "$lastparentgcsecs" ] &&
922 [ $lastparentgcsecs -lt $lastgcsecs ]; then
923 # We've run gc since our parent ran gc so we can skip
927 # We don't have any alternates (we're not a forK) so we can skip
932 # Prevent any other simultaneous gc operations
935 # At this point, if .allowgc or .gc_failed exists, it's now crud to be removed
936 rm -f .allowgc .gc_failed
938 # Ideally we would do this in post-receive, but that would mean duplicating the
939 # logic so it's available in the chroot jail and that's highly undesirable
940 # Instead, since the first gc will be triggered immediately following the first
941 # push, we do the check here as it's quick and harmless if HEAD is already valid
942 check_and_set_head ||
:
944 # Always get rid of crud
947 # Always perform reflogs maintenance
952 # Always maintain auto gc hack
953 maintain_auto_gc_hack
954 generate_auto_gc_update
956 # Run 'git svn gc' now for svn mirrors
957 if [ -n "$svn_mirror" ]; then
961 # Skip the actual gc if .delaygc is set
962 if [ -e .delaygc
]; then
963 progress
"x [$proj] garbage check delayed (except for crud removal)"
968 # Do not skip gc if the repo is dirty
969 if [ -n "$skipgc" ] && ! is_dirty
; then
970 progress
"= [$proj] garbage check nothing but crud removal to do ($(date))"
971 config_set lastgc
"$gcstart"
977 if [ -n "$isfork" ] && [ -z "$lastparentgcsecs" ]; then
978 # set lastparentgc and then update gcstart to be at least 1 second later
979 config_set lastparentgc
"$gcstart"
982 if [ -z "$lastreceivesecs" ]; then
983 # set lastreceive and then update gcstart to be at least 1 second later
984 config_set lastreceive
"$gcstart"
987 if [ -n "$bumptime" ]; then
989 gcstart
="$(date "$datefmt")"
992 progress
"+ [$proj] garbage check ($(date))"
995 [ -z "$alwaysredelta" ] || newdeltas
="$noreusedeltaopt"
996 if [ -z "$newdeltas" ] && [ -n "$gfi_mirror" ]; then
997 if [ $
(list_packs
--exclude-no-idx --count objects
/pack
) -le \
998 $
(list_packs
--exclude-no-idx --count --quiet --only gfi-packs
) ]; then
999 # Don't bother with repack_gfi_packs since everything's being repacked
1000 newdeltas
="--no-reuse-delta"
1003 if [ -z "$newdeltas" ] && [ -n "$noreusedeltaopt" ] &&
1004 [ $
(list_packs
--all --exclude-no-idx --count-objects objects
/pack
) -le $var_redelta_threshold ]; then
1005 # There aren't enough objects to worry about so just redelta to get the best pack
1006 newdeltas
="--no-reuse-delta"
1008 if [ -z "$newdeltas" ]; then
1009 # Since we're not going to recompute deltas overall, we need to do the
1010 # "mini" maintenance so that we can get more optimal deltas
1011 [ -z "$noreusedeltaopt" ] || make_needs_pack
1013 force_single_pack_redelta
=
1014 [ -n "$gfi_mirror" ] ||
[ -n "$svn_mirror" ] || force_single_pack_redelta
=1
1015 [ -z "$noreusedeltaopt" ] || combine_small_packs
$force_single_pack_redelta
1016 [ -z "$noreusedeltaopt" ] || combine_small_loose_packs
$force_single_pack_redelta
1020 ## Safe Pruning In Forks
1022 ## We are about to perform garbage collection. We do NOT use the "git gc" or
1023 ## the "git repack" commands directly as they do not provide enough control over
1024 ## the fine details. However, we DO maintain a "gc.pid" file during our garbage
1025 ## collection so that a simultaneous "git gc" by an administrator will be
1026 ## blocked (and similarly we refuse to start garbage collection if we cannot
1027 ## create the "gc.pid" file).
1029 ## When we say "gc" in the below description we are referring to our "gc.sh"
1030 ## script, NOT the "git gc" command.
1032 ## If the project we are running garbage collection (gc) on has any forks we
1033 ## must be careful not to remove any objects that while no longer referenced by
1034 ## this project (the parent) are still referenced by one or more forks (the
1035 ## children) otherwise the children will become corrupt and we can't abide
1036 ## corrupt children.
1038 ## One way to accomplish this is to simply hard-link all currently existing
1039 ## loose objects and packs in the parent into all the children that refer to the
1040 ## parent (via a line in their objects/info/alternates file) before beginning
1041 ## the gc operation and then relying on a subsequent gc in the child to clean up
1042 ## any excess objects/packs. We used to use this strategy but it's very
1043 ## inefficient because:
1045 ## 1. The disk space used by the old pack(s)/object(s) will not be reclaimed
1046 ## until all children (and their children, if any) run gc by which time
1047 ## it's quite possible the topmost parent will have run gc again and
1048 ## hard-linked yet another old pack down to its children (not to mention
1051 ## 2. When using the "-A" option with "git repack", any new objects in the
1052 ## parent that are not referenced by children will continually get
1053 ## exploded out of the hard-linked pack in the children whenever the
1056 ## 3. To avoid suboptimal and/or unnecessarily many packs being hard-linked
1057 ## into child forks, we must run the "mini" gc maintenance before we
1058 ## perform the hard-linking into the children which provides yet another
1059 ## source of inefficiency.
1061 ## While we were still using the "-A" option to "git repack" (that was not
1062 ## always the case) to guarantee we can access old ref values for long enough
1063 ## to send out a meaningful mail.sh notification, another, more efficient,
1064 ## option became available to prevent corruption of child forks that continue
1065 ## to refer to objects that are no longer reachable from any ref in the parent.
1067 ## The only things that need be copied (or hard-linked) into the child fork(s)
1068 ## are those objects that have become unreachable from any ref in the parent.
1070 ## When we were using the "git repack -A -d" + "git prune --expire=1.day.ago"
1071 ## technique, the only objects that could ever be removed were loose objects
1072 ## that "git prune" determined were expired. In that case, loose objects were
1073 ## all that need be hard-linked down to child forks in order to avoid
1074 ## corruption of any child fork(s).
1076 ## The "git repack -A -d" + "git prune --expire=1.day.ago" + hard-linking loose
1077 ## objects to child forks technique remains fundamentally sound from the
1078 ## perspective of supporting simultaneous gc and push and keeping newly
1079 ## unreachable objects around long enough to be sure we can send out meaningful
1080 ## ref change notifications and never corrupting any child forks and never
1081 ## persisting the lifetime of large old packs containing mostly duplicate or
1082 ## unreachable objects as gc percolates through a project's entire fork tree.
1084 ## However, that technique suffers from one potential prodigious pitfall.
1086 ## Unreachable objects come flying out of their packs to splatter all over the
1087 ## objects subdirectories possibly creating a huge, inefficient mess.
1089 ## Often this is not an issue. Even with a lot of rebasing going on, usually
1090 ## the only objects that will splatter are some commits, trees and the odd blob
1091 ## here and there. Not enough to be overly concerned about.
1093 ## However, for the reppository that frequently experiences a lot of non-fast-
1094 ## forward updates and/or outright ref deletion, the number of objects suddenly
1095 ## popping out of their packs at "git repack -A -d" time can be overwhelming.
1097 ## To avoid this issue we now use a four phase pack creation strategy.
1098 ## This will result in creation of up to four packs (instead of at most one).
1100 ## I. A complete pack (with bitmaps if appropriate) gets created including
1101 ## only "reachable" objects from all refs/... refs plus HEAD. This will
1102 ## also serve as the virtual bundle for the repository.
1104 ## II. A pack of recently-became-unreachable objects and friends is created.
1105 ## (The "friends" are ref logs, linked working tree HEADs and indicies.)
1106 ## Because both the pre-receive and update.sh script record all ref
1107 ## changes we can easily choose the cut off point for "recently".
1108 ## It is only the fact we maintain those logs in the reflogs subdirectory
1109 ## that allows this step to be possible.
1111 ## III. If the repository has any forks with a non-zero length alternates file,
1112 ## yet another pack of "--keep-unreachable" objects is generated that will
1113 ## not actually be kept in the parent, but hard-linked into all the forks.
1115 ## IV. Finally, after running "git prune-packed", any remaining loose objects
1116 ## are migrated into a pack of their own.
1118 ## We then remove any non-.keep packs that existed before we started the
1119 ## process being careful to keep any same-pack pushes for the "Push Pack Redux"
1120 ## race condition (see docs/technical/gc.txt).
1122 ## By using "git pack-objects" directly we are able to accomplish this with
1123 ## very little additional effort.
1125 ## The packs produced by (III) are treated almost like ".keep" packs by child
1126 ## forks in that the objects in them are never repacked into any other
1127 ## "--keep-unreachable" packs (but they can migrate into phase I or II packs)
1128 ## and those phase III packs are then hard-linked into any grandchild forks.
1130 ## This avoids the space explosion that could occur if each fork level ended
1131 ## up duplicating the "--keep-unreachable" pack space by repacking those
1132 ## objects (essentially breaking the hard-link to the single copy of those
1135 ## While it is true that each level of forks could potentially add yet another
1136 ## phase III pack to be hard-linked down to its children, such packs will only
1137 ## include unreachable objects not already in any phase III packs that were
1138 ## received from the parent.
1140 ## The space for the phase III packs will not be reclaimed until the gc
1141 ## finishes percolating through the entire "fork tree" of a project.
1143 ## This is not much different than the "git repack -A -d" situation where
1144 ## all the loose objects are hard-linked down into child forks. In that
1145 ## case forks that actually need any of those objects could gradually reduce
1146 ## the number of objects hard-linked into deeper fork levels.
1148 ## The difference with a phase III "--keep-unreachable" pack is that there
1149 ## cannot be any gradual reduction like that since it would require repacking
1150 ## the pack and breaking the hard-link thereby increasing storage space. The
1151 ## storage will instead always be reclaimed all at once when all of the
1152 ## projects in the "fork tree" complete their gc.
1154 ## However, the belief is that the huge space win by having all the
1155 ## unreachable objects packed up together far eclipses (when many objects are
1156 ## involved, the single-pack version can end up using 1/20th or less of the
1157 ## disk space compared to having them all as loose objects) any brief minor
1158 ## space savings that might occur under the "git repack -A -d" loose object
1159 ## system prior to the gc collection completing for all the projects in the
1164 ## utility functions
1168 find -L "$1" -maxdepth 1 -type f
! -perm -ug+w \
1169 -name "pack-$octet20*.pack" -exec chmod ug
+w
'{}' + ||
:
1173 if [ -s "$1" ]; then
1175 export GIT_INDEX_FILE
1176 git write-tree
2>/dev
/null ||
:
1177 unset GIT_INDEX_FILE
1181 get_detached_head
() {
1182 if [ -s "$1" ] && read -r _head
<"$1" 2>/dev
/null
; then
1183 case "$_head" in $octet20*)
1189 # compute_extra_reachables
1190 # create lines suitable for a packed-refs file mentioning all the
1191 # other refs we might like to keep.
1192 # the current directory MUST be set to the repository's --git-dir
1193 # the following are included:
1194 # * refs mentioned in repack/packed-refs.extra (if it exists)
1195 # * refs mentioned in reflogs/... files
1196 # * tree(s) created from index file(s)
1197 # * detached linked working tree heads
1198 # Resulting objects are tested for existence and uniqified then output
1199 # one per line under a refs/z* namespace
1200 compute_extra_reachables
() {
1202 if [ -s repack
/packed-refs.extra
]; then
1203 LC_ALL
=C
sed <repack
/packed-refs.extra
-n \
1204 -e 's/^\([0-9A-Fa-f][0-9A-Fa-f]*\).*$/\1/p' \
1205 -e 's/^\^\([0-9A-Fa-f][0-9A-Fa-f]*\).*$/\1/p'
1207 digits8
='[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]'
1208 find -L reflogs
-mindepth 1 -maxdepth 1 -type f
-name "$digits8*" -exec gzip -c -d -f '{}' + |
1209 awk '{print $2; print $3}'
1210 ! [ -f index
] || get_index_tree index
1211 if [ -d worktrees
]; then
1212 find -L worktrees
-mindepth 2 -maxdepth 2 -name HEAD
-type f
-print |
1213 while read -r lwth
; do
1214 get_detached_head
"$lwth"
1215 get_index_tree
"${lwth%HEAD}index"
1218 } | LC_ALL
=C
sort -u |
1219 git cat-file
${var_have_git_260:+--buffer} --batch-check"${var_have_git_185:+=%(objectname)}" |
1220 awk '!/missing/ {num++; print $1 " " "refs/" substr("zzzzzzzzzzzz", 1, length(num)) "/" num}'
1227 # Everything else is more efficient if we do this first
1228 # The "--prune" option is the default since v1.5.0 but it serves as "documentation" here
1229 git pack-refs
--all --prune
1230 [ -e packed-refs
] ||
>>packed-refs
# should never happen...
1232 # If we have a logs directory or a worktrees directory expire the ref logs now
1233 # Note that Git itself does not use either --rewrite or --updateref, so neither do we
1234 ! [ -d logs
] && ! [ -d worktrees
] ||
eval git reflog expire
--all "${quiet:+>/dev/null 2>&1}" ||
:
1237 ! [ -e .gc_failed
] ||
exit 1
1238 rm -f .gc_in_progress
# make sure
1239 touch .gc_in_progress
# it's truly fresh
1240 rm -f bundles
/* objects
/pack
/pack-
*.bndl
1241 # These only exist for a brief time before the packs loose their _f suffix
1242 # "Push Pack Redux" does not apply to these since they were only ever present with _f
1243 rm -f objects
/pack
/pack-
*_f.keep
1244 # This is perhaps a bit aggressive in that if we're suffering from "Push Pack Redux"
1245 # and somehow we get run again immediately after the run where "Push Pack Redux" happened
1246 # and we have garbage collection forced, there's just the barest, almost negligible,
1247 # possibility that the "Push Pack Redux" ref updates _still_ have not happened and we
1248 # should not be removing _r .keep files. None of the normal Girocco processing can
1249 # cause this. The second run of this script would have to use the force gc option
1250 # for it to even be possible in the first place. What's much more likely is that
1251 # the initial run of this script was somehow interrupted in the middle before it
1252 # could get rid of the _r .keep file itself in which case it's better to get rid of
1253 # it now to avoid keeping something around that would perturb our nice and neat gc
1254 rm -f objects
/pack
/pack-
*_r.keep
1255 # We will add .keep files for _u and _l packs if and when we run phase III
1256 # Otherwise they need to not have any .keep files during phases I and II
1257 rm -f objects
/pack
/pack-
*_
[ul
].keep
1259 # We need to make sure that any non-Girocco (barely tolerated) Git object creation
1260 # activity will be able to "freshen" the pack containing a pre-existing object
1261 # that's being written. This really should not be necessary as the pre-receive
1262 # hook should make sure this takes place for any incoming pushes.
1263 # However, do it here anyway just in case.
1264 make_packs_ugw objects
/pack
1266 # This is only effective with Git v2.3.5 and later and it will only matter when
1267 # we are using one of the "internal_rev_list" modes of pack-objects
1268 # (the combine-packs.sh script never uses any of those modes)
1269 # The "git repack" and "git prune" commands always set this internally themselves
1270 # It makes no difference if there's no repository corruption
1271 GIT_REF_PARANOIA
=1 && export GIT_REF_PARANOIA
1273 # All of the options we might want to use with pack-objects were supported
1274 # at some point prior to Git version v1.6.6 which is the minimum version that
1275 # Girocco now requires. Except for one (--use-bitmap-index). Several of them
1276 # are "boiler plate" options we always want to use so we bundle them up here.
1277 pkopt
="--delta-base-offset --keep-true-parents --non-empty --all-progress-implied"
1278 # We want to use --include-tag, but before Git v2.10.1 it would leave out
1279 # "middle" tags (e.g. a tag of a tag of a commit would omit the tagged tag)
1280 # See http://repo.or.cz/git.git/b773ddea2cd3b08c for details
1281 # ("pack-objects: walk tag chains for --include-tag", 2016-09-07, v2.10.1)
1282 # This is not a free check as it matches all refs against refs/tags/ then
1283 # peels all the annotated tags and checks for inclusion. The situation in
1284 # which it would add a tag that was not already included by a reachability
1285 # trace that included tag starting points can only occur if a new tag gets
1286 # pushed during gc pointing to something that would have been packed anyway.
1287 # But, it could happen and, really, compared to gc as a whole it's not that
1288 # expensive to perform (provided we do not get an unconnected pack).
1289 [ -z "$var_have_git_2101" ] || pkopt
="$pkopt --include-tag"
1290 pkopt
="$pkopt ${quiet:---progress} $packopts"
1292 # The git pack-objects command only supports bitmaps if all objects are being
1293 # packed (the "--all" option) and the "--stdout" option is NOT being used.
1294 # Additionally, while packing, if any encountered reachable objects are
1295 # determined to be "not wanted" then no bitmap index will be written anyway.
1296 # While it is theoretically possible that a project with a non-empty alternates
1297 # file ends up packing all objects (because it does not actually use any of the
1298 # objects found in the alternates), it's very unlikely. And, in the unlikely
1299 # event that did occur, clients would see a message about only using one bitmap
1300 # because Git can only use one bitmap at a time and at least one of the
1301 # alternates is bound to have a bitmap. Therefore if we see a non-empty
1302 # alternates file, we disable writing bitmaps which avoids the warning and any
1303 # possibility of a client warning as well. Also if we are running anything
1304 # before Git v2.1.0 (the effective version for repack.writeBitmaps=true) then
1305 # we also always disable bitmap writing.
1307 [ -z "$var_have_git_210" ] || wbmopt
="--write-bitmap-index"
1308 # More recent versions of pack-objects have optimizations when not using the
1309 # --local option. If we do not have any alternates it's a pointless option.
1310 # If we do have alternates we need to skip writing a bitmap and we cannot
1311 # have a bundle since it must contain all objects.
1312 if [ -n "$isfork" ]; then
1326 [ -n "$wbmopt" ] || wbmstr
=" (bitmaps disabled)"
1327 progress
"~ [$proj] running primary full gc pack-objects$wbmstr ($(date))"
1330 ! has_forks_with_alternates
"$proj" || gotforks
=1
1332 # To avoid "Push Pack Redux" (see docs/technical/gc.txt), after collecting the
1333 # initial preexisting non-keep pack list, we rename them so that an incoming push
1334 # pack cannot possibly experience a pack name collision. Git does not require
1335 # use of the "default" pack names, simply that the proper extensions are used.
1336 # We rename to insert an "_r" just before the extension to avoid "Push Pack Redux"
1337 # name collisions. Later on we may create an "unreachable" pack for hard-linking
1338 # down into forks and it will have an "_u" inserted just before its extension.
1339 packlist
="$(list_packs -C objects/pack --all --exclude-no-idx --exclude-keep --quiet .)" ||
:
1341 for oldpack
in $packlist; do
1342 oldpack
="${oldpack%.pack}"
1343 [ -f "objects/pack/$oldpack.pack" ] ||
{
1344 echo >&2 "[$proj] unable to list old pack files"
1347 case "$oldpack" in pre-auto-gc-
[12])
1348 # we never disturb pre-auto-gc-1 or pre-auto-gc-2 packs
1351 oldpackhex
="${oldpack#pack-}"
1352 if [ "${oldpackhex#*[!0-9a-fA-F]}" != "$oldpackhex" ]; then
1353 # names not exclusively hexadecimal do not need renaming
1356 # _l packs are treated like still-unpacked loose objects
1359 # _f packs can only be left over from a previously interrupted gc;
1360 # they need to be renamed to _r now so they're not confused with
1361 # any freshly generated "final" packs (and we already removed
1362 # any pre-existing *_f.keep files so we're good to go)
1365 oldpacks
="${oldpacks:+$oldpacks }$oldpack"
1369 rename_pack
"objects/pack/$oldpack" "objects/pack/${oldpack%_f}_r" ||
{
1370 echo >&2 "[$proj] unable to rename old pack files"
1373 # If the oldpack has a .keep now it means a "Push Pack Redux" is actually
1374 # in progress at this moment and we need to .keep the renamed pack,
1375 # otherwise no "Push Pack Redux" has started yet or it has already finished.
1376 # In either case we're okay because if it's just finished then all ref
1377 # changes have already been made so we don't need a .keep and we will
1378 # see the ref changes and grab all the objects via a reachability trace.
1379 # If it hasn't started yet that's okay because we're done moving that
1380 # name so a complete pack will appear under the old name that we'll
1382 if [ -f "objects/pack/$oldpack.keep" ]; then
1383 echo "Push Pack Redux" >"objects/pack/${oldpack%_f}_r.keep"
1385 oldpacks
="${oldpacks:+$oldpacks }${oldpack%_f}_r"
1389 # We wish to keep deltas from our last full pack so if we're not redeltaing
1390 # then make sure the .pack associated with the .bitmap has a newer mod time
1391 # (If there is no .bitmap then touch the pack with the most objects instead.)
1392 if [ -z "$newdeltas" ]; then
1393 bmpack
="$(list_packs --exclude-no-bitmap --exclude-no-idx --max-matches 1 objects/pack)"
1394 [ -n "$bmpack" ] || bmpack
="$(list_packs --exclude-no-idx --max-matches 1 --object-limit -1 --include-boundary objects/pack)"
1395 if [ -n "$bmpack" ] && [ -f "$bmpack" ] && [ -s "$bmpack" ]; then
1397 touch -c "$bmpack" 2>/dev
/null ||
:
1398 # We must touch .gc_in_progress here to avoid $bmpack looking
1399 # like it's been "freshened" when redundant packs are removed
1400 # It's okay if they have the same mod time, but POSIX does not
1401 # guarantee an ordering for the "touching" that occurs which is
1402 # why this must be a separate command but needs no "sleep 1"
1403 touch .gc_in_progress
1407 # Now we need to make sure that any "freshening" that takes place will actually
1408 # result in a "newer" modification time than the .gc_in_progress file now has
1411 # We run git pack-objects from the repack subdirectory so we can force
1412 # optimized packs to be generated even for repositories that do not have any
1414 packs
="$(git --git-dir=repack pack-objects </dev/null \
1415 $pkopt --all $newdeltas $lclopt ${wbmopt:---honor-pack-keep} "$@
" repack/alt/pack/pack)"
1417 [ $packcnt -eq 1 ] || makebndl
=
1423 progress
"~ [$proj] running supplementary gc pack-objects ($(date))"
1425 # Add the "supplementary" refs
1426 compute_extra_reachables
>>repack
/packed-refs
1428 # Subtract the primary refs
1429 GIT_ALTERNATE_OBJECT_DIRECTORIES
="$PWD/repack/alt"
1430 export GIT_ALTERNATE_OBJECT_DIRECTORIES
1432 # For this one we MUST use --local and MUST NOT use --write-bitmap-index
1433 # However, if there is a "logs" subdirectory we need to use --reflog
1434 # We do add it, just in case, if the linked working trees dir is present
1435 # We do not add --indexed-objects as that requires v2.2.0 and it's unclear
1436 # if it properly includes linked working tree index files or not. The
1437 # above compute_extra_reachables has already included all index trees (thereby
1438 # providing proper --indexed-objects support for all Git versions) making the
1439 # option completely unnecessary.
1441 ! [ -d logs
] && ! [ -d worktrees
] || rflopt
=--reflog
1442 spacks
="$(git --git-dir=repack pack-objects </dev/null \
1443 $pkopt --honor-pack-keep --all $rflopt $newdeltas --local "$@
" repack/alt/pack/pack)"
1449 # There's nothing to do for Phase III unless we have forks that refer to our
1450 # project from their alternates file
1453 if [ -n "$gotforks" ]; then
1455 progress
"~ [$proj] running keep-unreachable gc pack-objects for forks ($(date))"
1457 # If we are a fork, any pre-existing _u packs need to have a .keep
1458 # for this phase and be added to the hlpacks list otherwise (we are
1459 # not a fork) pre-existing _u packs are anomalies to be treated like
1460 # regular non-_u packs
1461 if [ -n "$isfork" ]; then
1462 for upack
in $
(find -L objects
/pack
-mindepth 1 -maxdepth 1 -name "pack-$octet20*_[ul].pack" -print); do
1463 upack
="${upack%.pack}"
1464 [ -e "$upack.keep" ] ||
echo "unreachable" >"$upack.keep"
1465 case "$upack" in *_l
);;*)
1466 hlpacks
="${hlpacks:+$hlpacks }${upack#objects/pack/pack-}"
1470 # Using either --no-reuse-delta or --no-reuse-object together with the
1471 # --keep-unreachable option is a very, very, very bad idea when good
1472 # packs are the desired outcome. If newdeltas are being generated
1473 # then we pack to a temp name, and use combine-packs.sh to get a better
1474 # pack as the result to avoid making a bad --keep-unreachable pack
1476 [ -z "$newdeltas" ] || pfx
="ku"
1477 upacks
="$(git --git-dir=repack pack-objects </dev/null \
1478 $pkopt --honor-pack-keep --all $rflopt --keep-unreachable --local "$@
" repack/alt/pack/${pfx}pack)"
1479 if [ -n "$upacks" ] && [ -n "$newdeltas" ]; then
1480 progress
"~ [$proj] rebuilding keep-unreachable pack deltas"
1483 printf "repack
/alt
/pack
/${pfx}pack-
%s.pack
\n" $oldupacks |
1484 run_combine_packs --names --weak-naming --non-empty --all-progress-implied ${quiet:---progress} \
1485 $packopts $newdeltas "$@
" repack/alt/pack/pack)"
1486 eval rm -f "$(printf \""repack
/alt
/pack
/${pfx}pack-
%s.
*"\"" " $oldupacks)"
1488 for upack
in $upacks; do
1489 rename_pack
"repack/alt/pack/pack-$upack" "repack/alt/pack/pack-${upack}_u"
1491 rm -f objects
/pack
/pack-
*_
[ul
].keep
1492 [ -z "$hlpacks" ] && [ -z "$upacks" ] ||
1493 progress
"~ [$proj] hard-linking keep-unreachable pack(s) into immediate child forks"
1495 # We have to update the lastparentgc time in the child forks even if they do not get any
1496 # new "unreachable packs" because they need to run gc just in case the parent now has some
1497 # objects that used to only be in the child so they can be removed from the child.
1498 # For example, a "patch" might be developed first in a fork and then later accepted into
1499 # the parent in which case the objects making up the patch in the child fork are now
1500 # redundant (since they're now in the parent as well) and need to be removed from the
1501 # child fork which can only happen if the child fork runs gc.
1502 lastparentgc
="$(date "$datefmt")"
1504 # It is enough to copy objects just one level down and get_repo_list
1505 # takes a regular expression (which is automatically prefixed with '^')
1506 # so we can easily match forks exactly one level down from this project
1508 get_repo_list
"$forkdir/[^/:][^/:]*:" |
1510 # Ignore forks that do not exist or are symbolic links
1511 ! [ -L "$cfg_reporoot/$fork.git" ] && [ -d "$cfg_reporoot/$fork.git" ] ||
1513 # Or do not have a non-zero length alternates file
1514 [ -s "$cfg_reporoot/$fork.git/objects/info/alternates" ] ||
1517 # Match hlpacks in parent project if any
1518 if [ -n "$hlpacks" ]; then
1519 mkdir
-p "$cfg_reporoot/$fork.git/objects/pack"
1520 eval ln -f "$(printf '"objects
/pack
/pack-
%s.pack
" ' $hlpacks)" \
1521 "$(printf '"objects
/pack
/pack-
%s.idx
" ' $hlpacks)" \
1522 '"$cfg_reporoot/$fork.git/objects/pack/"'
1525 # Match upacks in repack/alt area if any
1526 if [ -n "$upacks" ]; then
1527 mkdir
-p "$cfg_reporoot/$fork.git/objects/pack"
1528 eval ln -f "$(printf '"repack
/alt
/pack
/pack-
%s_u.pack
" ' $upacks)" \
1529 "$(printf '"repack
/alt
/pack
/pack-
%s_u.idx
" ' $upacks)" \
1530 '"$cfg_reporoot/$fork.git/objects/pack/"'
1533 if ! [ -e "$cfg_reporoot/$fork.git/.needsgc" ]; then
1534 # Trigger a mini gc in the fork if it now has too many packs
1535 packs
="$(list_packs --quiet --count --exclude-no-idx --exclude-keep "$cfg_reporoot/$fork.git
/objects
/pack
")" ||
:
1536 if [ -n "$packs" ] && [ "$packs" -ge 20 ]; then
1537 >"$cfg_reporoot/$fork.git/.needsgc"
1540 [ -z "$runupdate" ] || git
--git-dir="$cfg_reporoot/$fork.git" update-server-info
1541 # Update the fork's lastparentgc date (must be more recent than $gcstart)
1542 git
--git-dir="$cfg_reporoot/$fork.git" config gitweb.lastparentgc
"$lastparentgc"
1546 # Now move any primary/supplementary packs back into objects/pack
1547 # then drop any "unfreshened" redundant packs and clear repack/alt
1549 # First make sure the primary pack(s) have the most recent mod time
1550 if [ -n "$packs" ]; then
1551 [ -z "$spacks" ] ||
sleep 1
1552 printf 'repack/alt/pack/pack-%s.pack\n' $packs |
xargs touch -c 2>/dev
/null ||
:
1555 # Move the packs into place but with a _f suffix and a .keep file for now
1556 for pack
in $packs $spacks; do
1557 rename_pack
"repack/alt/pack/pack-$pack" "objects/pack/pack-${pack}_f"
1558 [ -e "objects/pack/pack-${pack}_f.keep" ] ||
1559 echo "final" >"objects/pack/pack-${pack}_f.keep"
1562 # It's possible that one of the $oldpacks had a .bitmap, got renamed (along
1563 # with its .bitmap) and then got "freshened" causing us to not remove it
1564 # However, if $wbmopt is set we most likely now have TWO .bitmap packs!
1565 # This can produce ugly warnings we don't want and possibly get the wrong
1566 # bitmap used since only one .bitmap file can ever be used by Git.
1567 # If this has happened, the .bitmap we want to discard will always have
1568 # an _r suffix so we can just zap any such now since it will leave the pack.
1569 [ -z "$wbmopt" ] ||
rm -f objects
/pack
/pack-
*_r.bitmap ||
:
1571 # Remove the redundant packs that have not since been "freshened"
1572 # This does not completely eliminate the race condition window (Girocco's own
1573 # activites -- gc/fetch/receive are immune to the race) but it substantially
1574 # shrinks it down to just the time after the find but before the following rm
1576 [ -z "$oldpacks" ] ||
1577 printf 'objects/pack/%s.pack\n' $oldpacks |
1578 LC_ALL
=C
sort >repack
/oldpacks
1579 find -L objects
/pack
-maxdepth 1 -type f
-name "pack-$octet20*.pack" -newer .gc_in_progress
-print |
1580 LC_ALL
=C
sort >repack
/freshened
1581 deadpacks
="$(LC_ALL=C join -v 1 repack/oldpacks repack/freshened | LC_ALL=C sed 's/\.pack$//')"
1582 [ -z "$deadpacks" ] ||
1583 eval echo "$(printf '"%s
".* ' $deadpacks)" |
xargs rm -f ||
:
1585 # No need for this anymore
1586 rm -rf repack
/alt objects
/pack
/repack
1587 unset GIT_ALTERNATE_OBJECT_DIRECTORIES
1593 progress
"~ [$proj] running gc prune-packed"
1595 # We do not want the redundant packs or any new "--keep-unreachable" pack(s) to be
1596 # present while running prune-packed. We try to guarantee that any loose object
1597 # (or any object present in a pack with an _l suffix which was created by mini gc)
1598 # that's unreachable persists for at least one $Girocco::Config::min_gc_interval
1599 # (not withstanding administrator interference to force earlier gc to occur).
1600 # If we were to include the redundant/keep-unreachable pack(s) when running
1601 # prune-packed and a loose unreachable object happened to be duplicated in one
1602 # of them we would end up removing it too soon and void our guarantee.
1603 git prune-packed
$quiet
1605 progress
"~ [$proj] running loose objects gc pack-objects ($(date))"
1607 # Although Git v2.10.0 and later support a --pack-loose-unreachable option,
1608 # we MUST NOT use it for these reasons:
1609 # 1) We're not interested in expensive "unreachable" at this point, only "loose"
1610 # 2) It produces simply horrid packs about 3.8x times larger than they should be
1611 # 3) We don't require anything more than Git v1.6.6
1612 # The only way we could see any _o pack files at this point is if one got
1613 # "freshened" while we were running gc. If that happens then it gets to live on
1614 # until the next full gc and we need to include it in the loose repack here.
1615 lpacks
="$(list_packs --exclude-no-idx --exclude-no-sfx _l --exclude-no-sfx _o --quiet objects/pack |
1616 run_combine_packs --replace --names --loose --weak-naming --non-empty --honor-pack-keep \
1617 --all-progress-implied ${quiet:---progress} $packopts $newdeltas "$@
")"
1619 if [ -n "$lpacks" ]; then
1620 # Make sure any primary pack(s) have a more recent mod time than "unreachable" objects packs
1621 if [ -n "$packs" ]; then
1623 printf 'objects/pack/pack-%s_f.pack\n' $packs |
xargs touch -c 2>/dev
/null ||
:
1625 # We need to identify these packs later so we don't combine_packs them
1626 for objpack
in $lpacks; do
1627 rename_pack
"objects/pack/pack-$objpack" "objects/pack/pack-${objpack}_o" ||
:
1631 # Polish up the final packs now
1632 rm -f objects
/pack
/pack-
*_f.keep
1633 for pack
in $packs $spacks; do
1634 rename_pack
"objects/pack/pack-${pack}_f" "objects/pack/pack-$pack"
1637 if [ -n "$lpacks" ]; then
1638 # Finally zap the corresponding loose objects
1639 progress
"~ [$proj] running packed loose objects gc prune-packed"
1640 git prune-packed
$quiet
1643 ! [ -e .gc_failed
] ||
exit 1
1644 # These, if they exist, are now meaningless and need to be removed
1645 rm -f gfi-packs .needsgc .needspack .needspackgc
1647 # Make sure this stays up to date
1648 git update-server-info
1650 # We must make loose objects group writable so that they
1651 # can be freshened by other pushers. Technically we need only do this for
1652 # push projects but to enable mirror projects to be more easily converted to
1653 # push projects, we go ahead and do it for all projects.
1654 # By the time we get here we really shouldn't have any of these, but just in case.
1655 { find -L objects
/$octet -type f
-name "$octet19*" -exec chmod ug
+w
'{}' + ||
:; } 2>/dev
/null
1657 # darcs:// mirrors have a xxx.log file that will grow endlessly
1658 # if this is a mirror and the file exists, shorten it to 10000 lines
1659 # also take this opportunity to optimize the darcs repo
1660 if ! [ -e .nofetch
] && [ -n "$cfg_mirror" ]; then
1661 url
="$(config_get baseurl)" ||
:
1662 case "$url" in darcs
://*)
1663 if [ -n "$cfg_mirror_darcs" ]; then
1665 basedarcs
="$(basename "${url#darcs:/}")"
1666 if [ -f "$basedarcs.log" ]; then
1667 tail -n 10000 "$basedarcs.log" >"$basedarcs.log.$$"
1668 mv -f "$basedarcs.log.$$" "$basedarcs.log"
1670 if [ -d "$basedarcs.darcs" ]; then
1672 cd "$basedarcs.darcs"
1673 # without show_progress suppress non-error output
1674 [ "${show_progress:-0}" != "0" ] ||
exec >/dev
/null
1675 # Note that this does not optimize _darcs/inventories/ :(
1683 # Create a matching .bndl header file for the all-in-one pack we just created
1684 # but only if we're not a fork (otherwise the bundle would not be complete)
1685 # and we are running at least Git version 1.7.2 (pack_is_complete always fails otherwise)
1686 if [ -n "$makebndl" ] && [ -n "$var_have_git_172" ]; then
1687 # There should only be one pack in $packs but do some checking...
1688 # The one we just created will have a .idx and will NOT have a .keep
1689 progress
"~ [$proj] creating downloadable bundle header"
1692 IFS
= read -r curhead
<repack
/HEAD.orig ||
:
1694 [ -s "objects/pack/pack-$packs.pack" ] &&
1695 [ -s "objects/pack/pack-$packs.idx" ] &&
1696 ! [ -e "objects/pack/pack-$packs.keep" ] &&
1697 pkhead
="$(pack_is_complete "$PWD/objects
/pack
/pack-
$packs.pack
" \
1698 "$PWD/repack
/packed-refs.orig
" "$curhead")"
1700 pkbase
="objects/pack/pack-$packs"
1702 if [ -n "$pkbase" ] && [ -n "$pkhead" ]; then
1705 case "$curhead" in "ref: refs/"?
*|
"ref:refs/"?
*|
"refs/"?
*)
1706 symref
="${curhead#ref:}"
1707 symref
="${symref# }"
1710 [ -z "$cfg_httpbundleurl" ] || bndlurl
=" url=$cfg_httpbundleurl/$proj.git/clone.bundle"
1711 echo "# v2 git bundle"
1712 LC_ALL
=C
sed -ne "/^$octet20$hexdig* refs\/[^ $tab]*\$/ p" <repack
/packed-refs.orig
1713 if [ -n "$symref" ]; then
1714 printf "$pkhead HEAD\0symref=HEAD:%s%s\n" "$symref" "$bndlurl"
1716 if [ -n "$bndlurl" ]; then
1717 printf "$pkhead HEAD\0%s\n" "${bndlurl:# }"
1724 bndletag
="$("$cfg_basedir/bin
/rangecgi
" --etag -m 1 "$pkbase.bndl
" "$pkbase.pack
")" ||
:
1725 bndlsha
="$(printf '%s' "$bndletag" | git hash-object --stdin)" ||
:
1726 if [ -n "$bndletag" ]; then
1727 case "$bndlsha" in $octet20*)
1728 bndlshatrailer
="${bndlsha#????????}"
1729 bndlshaprefix
="${bndlsha%$bndlshatrailer}"
1730 bndlname
="$(TZ=UTC date +%Y%m%d_%H%M%S)-${bndlshaprefix:-0}"
1731 [ -d bundles
] || mkdir bundles
1732 echo "${pkbase#objects/pack/}.bndl" >"bundles/$bndlname"
1733 echo "${pkbase#objects/pack/}.pack" >>"bundles/$bndlname"
1734 ln -s -f -n "$bndlname" bundles
/latest
1740 # Record the size of this repo as the sum of its clone packed-refs + *.pack sizes as 1024-byte blocks
1741 eval "reposizek=$(( $(
1742 echo 0 $(du -k repack/packed-refs.orig $(printf 'objects/pack/pack-%s.pack ' $packs) 2>/dev/null |
1743 LC_ALL=C awk '{print $1}') |
1744 LC_ALL=C sed -e 's/ / + /g') ))"
1745 config_set_raw girocco.reposizek
"${reposizek:-0}"
1747 # Now we're finally done with this
1750 # We didn't used to do anything about rerere or worktrees but we're
1751 # trying to make nice with linked working trees these days :)
1752 # Maybe even non-bare repositories too, but *shush* about those ;)
1753 if [ -n "$var_have_git_250" ] && [ -d worktrees
]; then
1754 # The value "3.months.ago" is hard-coded into gc.c rather than
1755 # having the default be in worktree.c so we must provide it if
1756 # we get nothing out of the gc.worktreePruneExpire config item
1757 # Prior to Git v2.6.0 the config item was gc.pruneworktreesexpire
1758 # however we just always use the newer name no matter what Git version
1759 expiry
="$(git config --get gc.worktreePruneExpire 2>/dev/null)" ||
:
1760 eval git worktree prune
--expire '"${expiry:-3.months.ago}"' "${quiet:+>/dev/null 2>&1}" ||
:
1762 # git rerere does it right and handles its own default/config'd expiration values
1763 ! [ -d rr-cache
] ||
eval git rerere gc
"${quiet:+>/dev/null 2>&1}" ||
:
1765 # We use $gcstart here to avoid a race where a push occurs during the gc itself
1766 # and the next future gc could be incorrectly skipped if we used the current
1767 # timestamp here instead
1768 config_set lastgc
"$gcstart"
1771 progress
"- [$proj] garbage check ($(date))"