41

I'm trying to write a shell script that will wait for a file to appear in the /tmp directory called sleep.txt and once it is found the program will cease, otherwise I want the program to be in a sleep (suspended) state until the file is located. Now, I'm assuming that I will use a test command. So, something like 

(if [ -f "/tmp/sleep.txt" ]; 
then stop 
   else sleep.)

I'm brand new to writing shell script and any help is greatly appreciated!

Improve this question
2
  • Look at $MAILPATH. Commented Feb 18, 2015 at 12:01
  • FWIW, using a filename such as wakeup.txt or terminate.txt instead of sleep.txt perhaps would be a more obvious choice for signaling your script to continue with its execution ... after it was in a state of sleep ... Commented Apr 14, 2023 at 0:08

5 Answers 5

Reset to default
57

Under Linux, you can use the inotify kernel subsystem to efficiently wait for the appearance of a file in a directory:

inotifywait -e create,moved_to,attrib --include '/sleep\.txt$' -qq /tmp
# script execution continues ...

NB: I included the attrib event to also register touch /tmp/sleep.txt when the file already exists.

In cases where there is a race condition between sleep.txt showing up and the inotifywait invocation, i.e. when the file might be created or touched just before the watch is established - and then never again, afterwards - one can extend the code like this (here assuming a recent version of the bash shell):

coproc inw {
    LC_ALL=C exec inotifywait -e create,moved_to --include '/sleep\.txt$' /tmp 2>&1
}
while IFS= read -r -u "${inw[0]}" line; do
    if [ "$line" = "Watches established." ]; then
        break
    fi
done
if [ -e /tmp/sleep.txt ]; then
    kill "$inw_PID"
else
    wait
fi
# script execution continues ...

The advantage of this approach in comparison to fixed time interval polling like in

until [ -e /tmp/sleep.txt ]; do sleep 1; done
# script execution continues ...

is that your process sleeps more. With an inotify event specification like create,moved_to,attrib the script is just scheduled for execution when a file under /tmp is created or has its attributes modified. With the fixed time interval polling you waste CPU cycles for each time increment.

Improve this answer
12
  • Thanks, this is awesome! Why do you need the while loop if you know the name of the file? Why couldn't that just have been inotifywait -e create,open --format '%f' --quiet /tmp/sleep.txt --monitor > /dev/null ; # continues once /tmp/sleep.txt is created/opened? Commented Aug 30, 2017 at 3:45
  • Oh, jk. After installing the tool I understand now. inotifywait is itself a while loop, and it outputs a line every time the file is opened/created. So you need the while loop to break when it's changed. Commented Aug 30, 2017 at 3:51
  • 2
    except that this produces a race condition - unlike the test -e/sleep version. There is no way to guarantee that the file won't be created right before the loop is entered - in which case the event will be missed. You'd need to add something like ( sleep 1; [[ -e /tmp/sleep.txt ]] && touch /tmp/sleep.txt ; ) & before the loop. Which of course might create issues down the road, depending on actual business logic Commented Jul 2, 2018 at 18:59
  • @n-alexander Well, the answer assumes that you execute the snippet before you start the process that will produce sleep.txt at some point in time. Thus, no race condition. The question doesn't contain anything hinting at a scenario you have in mind. Commented Jul 2, 2018 at 20:05
  • 1
    @MarioPalumbo out of paranoia that ionotifywait is localized, i.e. to avoid getting translated messages and thus never matching 'Watches established.'. However, this doesn't seem to be an issue as of 3.22.1, e.g. on Fedora 37 with de_DE locales available LC_ALL=de_DE or LC_MESSAGES=de_DE don't show different messages. However, this might change in the future. Commented Apr 14, 2023 at 10:08
31

Just put your test in the while loop:

while [ ! -f /tmp/sleep.txt ]; do sleep 1; done
# next command
Improve this answer
3
  • So as you have written it, this is the logic: while the file doesn't exist, the script will sleep. Otherwise, it is done. Correct? Commented Feb 17, 2015 at 12:36
  • @MoGainz Correct. The number after sleep is number of seconds to wait in each iteration - you can change that depending on your needs. Commented Feb 17, 2015 at 12:38
  • 1
    This solution is short and to the point, plus it does not use any external command. I like it. Commented Feb 18, 2021 at 15:52
13

There are a few problems with some of the inotifywait-based approaches given so far:

  • they fail to find a sleep.txt file that has been created first as a temporary name and then renamed to sleep.txt. One needs to match for moved_to events in addition to create
  • file names can contain newline characters, printing the names of the files newline delimited is not enough to determine if a sleep.txt has been created. What if a foo\nsleep.txt\nbar file has been created for instance?
  • what if the file is created before inotifywait has been started and installed the watch? Then inotifywait would wait forever for a file that is already here. You'd need to make sure the file is not already there after the watch has been installed.
  • some of the solutions leave inotifywait running (at least until another file is created) after the file has been found.

To address those, you could do:

sh -c 'echo "$$" &&
        LC_ALL=C exec inotifywait -me create,moved_to --format=/%f/ . 2>&1' | {
  IFS= read pid &&
    while IFS= read -r line && [ "$line" != "Watches established." ]; do
      : wait for watches to be established
    done
  [ -e sleep.txt ] || [ -L sleep.txt ] || grep -qxF /sleep.txt/ && kill "$pid"
}

Note that we're watching for the creation of sleep.txt in the current directory, . (so you'd do a cd /tmp || exit before in your example). The current directory never changes, so when that pipe line returns successfully, it is a sleep.txt in the current directory that has been created.

Of course, you can replace . with /tmp above, but while inotifywait is running, /tmp could have been renamed several times (unlikely for /tmp, but something to consider in the general case) or a new filesystem mounted on it, so when the pipeline returns, it may not be a /tmp/sleep.txt that has been created but a /new-name-for-the-original-tmp/sleep.txt instead. A new /tmp directory could also have been created in the interval and that one wouldn't be watched, so a sleep.txt created there wouldn't be detected.

Improve this answer
1

The accepted answer really works (thanks maxschlepzig) but leaves the inotifywait monitoring in the background until your script exits. The only answer that matches exactly your requirements (ie waiting for sleep.txt to show up inside /tmp) seems to be Stephane's, if the directory to be monitored by inotifywait is changed from dot (.) to '/tmp'.

However, if you are willing to use a temporary directory ONLY for putting your sleep.txt flag and can bet that nobody else will put any file in that directory, just asking inotifywait to watch this directory for file creations would be sufficient:

1st step: create the directory you will monitor:

directoryToPutSleepFile=$(mktemp -d)

2nd step: make sure the directory is really there

until [ -d $directoryToPutSleepFile ]; do sleep 0.1; done

3rd step: wait until ANY file shows up inside $directoryToPutSleepFile

inotifywait -e create --format '%f' --quiet $directoryToPutSleepFile

The file you will put in $directoryToPutSleepFile can be named sleep.txt awake.txt, whatever. The moment any file is created inside $directoryToPutSleepFile your script will continue past the inotifywait statement.

Improve this answer
9
  • 1
    But that could miss the creation of the file, if another one was created just before, causing the sleep.txt to be created inbetween two inotifywait invocations. Commented Nov 27, 2017 at 14:41
  • see my answer for an alternative way to address it. Commented Nov 27, 2017 at 15:03
  • Please try my code. inotifywait is invoked only once. When sleep.txt is created (or read/written if already there), inotifywait outputs "sleep.txt" and the execution continues after the 'done' statement. Commented Nov 27, 2017 at 15:14
  • It's invoked several times until a file called sleep.txt is created. Try for instance touch /tmp/foo /tmp/sleep.txt, then one instance of inotifywait will report foo and exit, and by the time the next inotifywait is started, the sleep.txt will have long been there already so inotifywait will not detect its creation. Commented Nov 27, 2017 at 15:21
  • 1
    You were right about the multiple invocations: one invocation for every file created under /tmp. I updated my answer. Thanks for your comment. Commented Nov 27, 2017 at 15:43
1

Based on the accepted answer of maxschlepzig (and an idea from the accepted answer at https://superuser.com/questions/270529/monitoring-a-file-until-a-string-is-found) I propose the following improved (in my view) answer which can also work with timeout:

# Enable pipefail, so if the left side of the pipe fails it does not get silently ignored
set -o pipefail
( timeout 120 inotifywait -e create,open --format '%f' --quiet /tmp --monitor & ) | while read i; do if [ "$i" == 'sleep.txt' ]; then break; fi; done
EXIT_STATUS=$?
if [ "${EXIT_STATUS}" == '124' ]; then
  echo "Timeout happened"
fi

In case the file does not get created/opened within the given timeout, then the exit status is 124 (as per timeout documentation (man page)). In case it gets created/opened, then the exit status is 0 (success).

Yes, inotifywait runs in a sub-shell this way and that sub-shell will only finish running when the timeout happens or when the main script exits (whichever comes first).

Improve this answer

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.