jobd/updategc-util-functions.sh

   1 #!/bin/sh
   2 #
   3 # This is a shell library for common update/gc related functions
   4 # used by various Girocco scripts.
   5
   6 # shlib.sh always sets this, it's an error to source
   7 # this script without having already sourced shlib.sh
   8 [ -n "$var_git_exec_path" ] || exit 2
   9
  10 pidactive() {
  11         if _result="$(kill -0 "$1" 2>&1)"; then
  12                 # process exists and we have permission to signal it
  13                 return 0
  14         fi
  15         case "$_result" in *"not permitted"*)
  16                 # we do not have permission to signal the process
  17                 return 0
  18         esac
  19         # process does not exist
  20         return 1
  21 }
  22
  23 createlock() {
  24         # A .lock file should only exist for much less than a second.
  25         # If we see a stale lock file (> 1h old), remove it and then,
  26         # just in case, wait 30 seconds for any process whose .lock
  27         # we might have just removed (it's racy) to finish doing what
  28         # should take much less than a second to do.
  29         _stalelock="$(find -L "$1.lock" -maxdepth 1 -mmin +60 -print 2>/dev/null)" || :
  30         if [ -n "$_stalelock" ]; then
  31                 rm -f "$_stalelock"
  32                 sleep 30
  33         fi
  34         for _try in p p n; do
  35                 if (set -C; >"$1.lock") 2>/dev/null; then
  36                         echo "$1.lock"
  37                         return 0
  38                 fi
  39                 # delay and try again
  40                 [ "$_try" != "p" ] || sleep 1
  41         done
  42         # cannot create lock file
  43         return 1
  44 }
  45
  46 # Create a new lockfile
  47 # $1 => name of variable to store result in
  48 # $2 => name of the new lockfile (default is "lockfile.pid")
  49 # On success:
  50 #   variable named by $1 will contain the name of the newly create lockfile (i.e. "$2")
  51 # On failure:
  52 #   variable named by $1 will contain the failure reason
  53 v_lock_file() {
  54         # be compatibile with gc.pid file from newer Git releases
  55         _lockf="${2:-lockfile.pid}"
  56         _hn="$(hostname)"
  57         _active=
  58         if [ "$(createlock "$_lockf")" ]; then
  59                 # If $_lockf is:
  60                 #   1) less than 12 hours old
  61                 #   2) contains two fields (pid hostname) NO trailing NL
  62                 #   3) the hostname is different OR the pid is still alive
  63                 # then we exit as another active process is holding the lock
  64                 if [ "$(find -L "$_lockf" -maxdepth 1 -mmin -720 -print 2>/dev/null)" ]; then
  65                         _apid=
  66                         _ahost=
  67                         read -r _apid _ahost _ajunk <"$_lockf" || :
  68                         if [ "$_apid" ] && [ "$_ahost" ]; then
  69                                 if [ "$_ahost" != "$_hn" ] || pidactive "$_apid"; then
  70                                         _active=1
  71                                 fi
  72                         fi
  73                 fi
  74         else
  75                 eval "$1="'"unable to create $_lockf.lock file"'
  76                 return 1
  77         fi
  78         if [ -n "$_active" ]; then
  79                 rm -f "$_lockf.lock"
  80                 eval "$1="'"gc already running on machine '\''$_ahost'\'' pid '\''$_apid'\''"'
  81                 return 1
  82         fi
  83         printf "%s %s" "$$" "$_hn" >"$_lockf.lock"
  84         chmod 0664 "$_lockf.lock"
  85         mv -f "$_lockf.lock" "$_lockf"
  86         eval "$1="'"$_lockf"'
  87         return 0
  88 }
  89
  90 # duplicate the first file to the name given by the second file making sure that
  91 # the second file appears atomically all-at-once after the copy has been completed
  92 # and does not appear at all if the copy fails (in which case this function fails)
  93 # if the second file already exists this function fails with status 1
  94 # if the file names are the same this function returns immediately with success
  95 dupe_file() {
  96         [ "$1" != "$2" ] || return 0
  97         ! [ -e "$2" ] || return 1
  98         case "$2" in
  99                 *?/?*)  _tmpdir="${2%/*}";;
 100                 *)      _tmpdir=".";;
 101         esac
 102         _tmpfile="$(mktemp "${_tmpdir:-.}/packtmp-XXXXXX")" || return 1
 103         cp -fp "$1" "$_tmpfile" || return 1
 104         mv -f "$_tmpfile" "$2"
 105 }
 106
 107 # rename_pack oldnamepath newnamepath
 108 # note that .keep and .bndl files are left untouched and not moved at all!
 109 rename_pack() {
 110         [ $# -eq 2 ] && [ "$1" != "$2" ] || {
 111                 echo >&2 "[$proj] incorrect use of rename_pack function"
 112                 exit 1
 113         }
 114         # Git assumes that if the destination of the rename already exists
 115         # that it is, in fact, a copy of the same bytes so silently succeeds
 116         # without doing anything.  We duplicate that logic here.
 117         # Git checks for the .idx file first before even trying to use a pack
 118         # so it should be the last moved and the first removed.
 119         for ext in pack bitmap idx; do
 120                 [ -f "$1.$ext" ] || continue
 121                 ln "$1.$ext" "$2.$ext" >/dev/null 2>&1 ||
 122                 dupe_file "$1.$ext" "$2.$ext" >/dev/null 2>&1 ||
 123                 [ -f "$2.$ext" ] || {
 124                         echo >&2 "[$proj] unable to move $1.$ext to $2.$ext"
 125                         exit 1
 126                 }
 127         done
 128         for ext in idx pack bitmap; do
 129                 rm -f "$1.$ext"
 130         done
 131         return 0
 132 }