Current File : //proc/thread-self/root/bin/run-one-until-success
#!/bin/sh -e
#
# run-one - run just one instance at a time of some command and
# unique set of arguments (useful for cronjobs, eg)
#
# run-this-one - kill any identical command/args processes
# before running this one
#
# run-one-constantly - run-one, but respawn every time that one exits
#
# run-one-until-success - run-one, but respawn until a successful exit
#
# run-one-until-failure - run-one, but respawn until an unsuccessful exit
#
# Copyright (C) 2010-2013 Dustin Kirkland <kirkland@ubuntu.com>
#
# Authors:
# Dustin Kirkland <kirkland@ubuntu.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
PROG="run-one"
if [ $# -eq 0 ]; then
echo "ERROR: no arguments specified" 1>&2
exit 1
fi
# Cache hashes here, to keep one user from DoS'ing another
# Test if home is writeable and owned by the current user;
# which is not always the case -- e.g. daemon
USER=$(id -un)
for i in "${HOME}" "/dev/shm/${PROG}_${USER}"*; do
if [ -w "$i" ] && [ -O "$i" ]; then
DIR="$i"
break
fi
done
if [ -w "${DIR}" ] && [ -O "${DIR}" ]; then
DIR="${DIR}/.cache/${PROG}"
else
DIR=$(mktemp -d "/dev/shm/${PROG}_${USER}_XXXXXXXX")
DIR="${DIR}/.cache/${PROG}"
fi
mkdir -p "$DIR"
# Calculate the hash of the command and arguments
CMD="$@"
CMDHASH=$(echo "$CMD" | md5sum | awk '{print $1}')
FLAG="$DIR/$CMDHASH"
base="$(basename $0)"
case "$base" in
run-one)
# Run the specified command, assuming we can flock this command string's hash
flock -xn "$FLAG" "$@"
;;
run-this-one)
ps="$CMD"
# Loop through matching pids
for p in $(pgrep -u "$USER" -f "^$ps$" || true); do
# Try to kill pid
kill $p
# And then block until killed
while ps $p >/dev/null 2>&1; do
kill $p
sleep 1
done
done
# Also try to use lsof, but it seems that flock()'s
# are not always persistent enough, so this is purely auxilliary.
pid=$(lsof "$FLAG" 2>/dev/null | awk '{print $2}' | grep "^[0-9]") || true
[ -z "$pid" ] || kill $pid
sleep 0.5
# Run the specified command, assuming we can flock this command string's hash
flock -xn "$FLAG" "$@"
;;
keep-one-running|run-one-constantly|run-one-until-success|run-one-until-failure)
backoff=0
retries=0
while true; do
# Run the specified command, assuming we can flock this command string's hash
set +e
flock -xn "$FLAG" "$@"
if [ "$?" = 0 ]; then
# If we were waiting for success, we're done
[ "$base" = "run-one-until-success" ] && exit $?
# Last run finished successfully, reset to minimum back-off of 1 second
backoff=0
backoff=0
else
# If we were waiting for failure, we're done
[ "$base" = "run-one-until-failure" ] && exit $?
# Last run failed, so slow down the retries
retries=$((retries + 1))
backoff=$((retries / 10))
logger -t "${base}[$$]" "last run failed; sleeping [$backoff] seconds before next run"
fi
# Don't sleep more than 60 seconds
[ $backoff -gt 60 ] && backoff=60
sleep $backoff
done
;;
esac
Mini Shell