find -exec exit 1 \; Doesn't work neither does find -exec sh -c exit 1 \;

Question

Using Enterprise Linux 5/6, Bash 4.x I want this type of logic:

# IF temp file exists, exit because we are restarting already     
find /tmp/restarting_server -mmin -10 -exec exit 1

lsof -i TCP:1234 || declare Server_is_down=TRUE
    if ! [ -z $Server_is_down ]; then restart_server
    fi
# Restart Server Function
restart_server() {
    touch /tmp/restarting_server 
    service server restart
    rm -f /tmp/restarting_server 
}

The problem is find's -exec doesn't like builtins it seems. I know I can do an if then statement to check for the file and exit there, but I want to know how to do this in a find -exec (or I'd settle for a good xargs solution).

Answer 1

You could check if it returned a result:

[ -z "$(find /tmp/restarting_server -prune -mmin -10)" ] || exit 1

Answer 2

while [ -f /tmp/restarting_server ] ; do {
    [ $((i=i+1)) -ge 10 ] && exit 1
    sleep 1 
} ; done

You dont need find if you know already the exact filename, pathname, and conditions under which a file should be acceptably found.

So the other problem - exiting your script from your -exec statement - is maybe not the problem you consider it to be. find doesn't build in an option for killing its parent shell because the shell already provides it.

find … -exec sh -c kill\ $$ \;

Consider also that you can use this construct for signalling based on existing paths even if you're not certain before hand where they'll be:

trap 'stuff to do' USR1    
… #later… 
find … -exec sh -c kill\ -USR1\ $$ \;

And this opens a lot of other options to you as well:

find … -exec sh -c exec… 

EDIT:

I've just thought of other options involving parameter expansion to make your shell exit without find's -exec at all that could be used in other ways:

hold_file="$(find . -name file)"
${hold_file:+false} : || exit 1

or

N= ; hold_file="$(find . -name file)"
${hold_file:+${N:?lock file remains, exiting...}}

Both of these will only cause an exit if the variable to which you assign find's stdout is neither null or unset. And of course, should you desire to fail based on an empty find, you can do the same with :- instead of :+ and omitting the $Null value variable entirely.

Or just to alter find's exit status:

$(find . -name file -exec echo false \; ) : || exit 1

Answer 3

find is a program of its own. The argument to -exec is another command. When a command like find … -exec foo {} \; is executed, the shell has find as a subprocess, and each instance of foo is a subprocess of find. The command exit exists only as a shell builtin, not as an independent command; an exit program would be impossible since it would have to make its parent process exit.

The solution to your immediate problem is thus to make find report whether it found a file or not, and make the shell exit if there was a match. You can't use the return status of find, because it considers the absence of any match to be a success reason. Instead, test the output.

if [ -n "$(find /tmp/restarting_server -mmin -10)" ]; then exit; fi

Here, the file should be a regular file if it exists at all. However, in general, the file could be a directory, in which case find would traverse it. So tell find to stop when it finds a match.

if [ -n "$(find /tmp/restarting_server -mmin -10 -prune)" ]; then exit; fi

---

However, the resulting script is not reliable. You are not implementing a lock correctly. If two instances of the script start at almost the same time, it's possible to have, for example:

1. Script 1 starts, sees no restarting_server file, and proceeds merrily.
2. Script 2 starts, sees no restarting_server file, and proceeds merrily.
3. Script 1 sees that the server is down and decides to restart it.
4. Script 2 sees that the server is down and decides to restart it.
5. Script 1 creates /tmp/restarting_server.
6. Script 2 updates the timestamp on /tmp/restarting_server.
7. Script 1 calls service server restart.
8. Script 2 calls service server restart.
9. Script 1 removes /tmp/restarting_server.
10. Script 2 calls rm -f /tmp/restarting_server which does nothing.

Call flock to implement proper locking.

(
  lsof -i TCP:1234 >/dev/null ||
  service server restart
) 3>/var/lock/maybe_restarting_server

You don't need a timeout to invalidate the lock across reboots, since the locking is held in-memory.

Answer 4

You can simply do this:

if [ "$(find /tmp -maxdepth 1 -mindepth 1 -name restarting_server -mmin -10)" = '/tmp/restarting_server' ]
then
    exit 1
fi

This works even if you're using set -o errexit (which you should).