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 # $3 => "type" name to use in error message (default is ${2%%.*})
  50 # On success:
  51 #   variable named by $1 will contain the name of the newly create lockfile (i.e. "$2")
  52 # On failure:
  53 #   variable named by $1 will contain the failure reason
  54 v_lock_file() {
  55         # be compatibile with gc.pid file from newer Git releases
  56         _lockf="${2:-lockfile.pid}"
  57         _locktype="${3:-${2%%.*}}"
  58         _hn="$(hostname)"
  59         _active=
  60         if [ "$(createlock "$_lockf")" ]; then
  61                 # If $_lockf is:
  62                 #   1) less than 12 hours old
  63                 #   2) contains two fields (pid hostname) NO trailing NL
  64                 #   3) the hostname is different OR the pid is still alive
  65                 # then we exit as another active process is holding the lock
  66                 if [ "$(find -L "$_lockf" -maxdepth 1 -mmin -720 -print 2>/dev/null)" ]; then
  67                         _apid=
  68                         _ahost=
  69                         read -r _apid _ahost _ajunk <"$_lockf" || :
  70                         if [ "$_apid" ] && [ "$_ahost" ]; then
  71                                 if [ "$_ahost" != "$_hn" ] || pidactive "$_apid"; then
  72                                         _active=1
  73                                 fi
  74                         fi
  75                 fi
  76         else
  77                 eval "$1="'"unable to create $_lockf.lock file"'
  78                 return 1
  79         fi
  80         if [ -n "$_active" ]; then
  81                 rm -f "$_lockf.lock"
  82                 eval "$1="'"$_locktype already running on machine '\''$_ahost'\'' pid '\''$_apid'\''"'
  83                 return 1
  84         fi
  85         printf "%s %s" "$$" "$_hn" >"$_lockf.lock"
  86         chmod 0664 "$_lockf.lock"
  87         mv -f "$_lockf.lock" "$_lockf"
  88         eval "$1="'"$_lockf"'
  89         return 0
  90 }
  91
  92 # duplicate the first file to the name given by the second file making sure that
  93 # the second file appears atomically all-at-once after the copy has been completed
  94 # and does not appear at all if the copy fails (in which case this function fails)
  95 # if the second file already exists this function fails with status 1
  96 # if the file names are the same this function returns immediately with success
  97 dupe_file() {
  98         [ "$1" != "$2" ] || return 0
  99         ! [ -e "$2" ] || return 1
 100         case "$2" in
 101                 *?/?*)  _tmpdir="${2%/*}";;
 102                 *)      _tmpdir=".";;
 103         esac
 104         _tmpfile="$(mktemp "${_tmpdir:-.}/packtmp-XXXXXX")" || return 1
 105         cp -fp "$1" "$_tmpfile" || return 1
 106         mv -f "$_tmpfile" "$2"
 107 }
 108
 109 # rename_pack oldnamepath newnamepath
 110 # note that .keep and .bndl files are left untouched and not moved at all!
 111 rename_pack() {
 112         [ $# -eq 2 ] && [ "$1" != "$2" ] || {
 113                 echo >&2 "[$proj] incorrect use of rename_pack function"
 114                 exit 1
 115         }
 116         # Git assumes that if the destination of the rename already exists
 117         # that it is, in fact, a copy of the same bytes so silently succeeds
 118         # without doing anything.  We duplicate that logic here.
 119         # Git checks for the .idx file first before even trying to use a pack
 120         # so it should be the last moved and the first removed.
 121         for ext in pack bitmap idx; do
 122                 [ -f "$1.$ext" ] || continue
 123                 ln "$1.$ext" "$2.$ext" >/dev/null 2>&1 ||
 124                 dupe_file "$1.$ext" "$2.$ext" >/dev/null 2>&1 ||
 125                 [ -f "$2.$ext" ] || {
 126                         echo >&2 "[$proj] unable to move $1.$ext to $2.$ext"
 127                         exit 1
 128                 }
 129         done
 130         for ext in idx pack bitmap; do
 131                 rm -f "$1.$ext"
 132         done
 133         return 0
 134 }