UNIX for Dummies Questions & Answers

I want to be able to lock a file for 60 minutes so that an automated monitoring program will not execute the script more that once an hour. I have never used a lock file but have heard that is what I need to use. Does anyone have any examples of how I would use this?

lock 60 filename.ksh ---?

Thanks,

A "lock" file is nothing more than an ordinary file
that is used a a sort of "semaphore". Meaning, for example,
you can create a lock file from within a shell script
(say "myprog.ksh")
that can contain the shell script's process ID by doing...

echo $$ > /tmp/myprog..LCK

...this will create the file called "myprog..LCK" in the
"/tmp" directory. This file will contain the process id of
the shell script "myprog.ksh" for that particular instance
in which it was run.

There are several good reasons to do this. For instance,
"myprog.ksh" may be executed every 60min via "cron" but
occasionally make take more than 60min to complete. Therefore
you may wish to skip execution if the previous execution
is still running.

However, I'm not exactly clear on your requirements. It may
be that a lock file is not necessary. For example, if you wanted to
execute a shell script every 60min you could simply create a
"cron" job to run at 60min intervals.

We have a program that monitors application events that can happen at any given time. When that event happens another script is executed to send an email or a page. Some application events happen quite frequently and we want to limit the number of notifications we receive within a certain time period. It was understood that integrating some type of lock file would be a good resolution to the problem.

- Thanks rwb1959

OK that clears it up a bit...

You pager/email-er shell script might include code like...

#!/bin/sh

if [ -f /tmp/myprog..LCK ]
then
exit 0
fi

echo $$ > /tmp/myprog..LCK
...
Do your paging and email stuff here
...

sleep 3600

rm -f /tmp/myprog..LCK
exit 0

I have this same problem except when I create the semaphore file using a shell script, what happens if the shell script fails and the semaphore file is sitting out there forever?

So, the next time the script runs, it sees the semaphore file and doesn't run.

I need something like a 'finally' block in Java where if the shell script bails out, it needs to remove the semaphore file.

Any idea how to do this using shell scripting?

One solution is to put the uid of the creating process in the file:
echo $$ > $lockfile


Then if the lockfile exists, do a secondary check to see if the process is still around:
lpid=`cat $lockfile`
if kill -0 $lpid ; then
echo locked by process $lpid
exit 1
else
echo $$ > $lockfile
fi

This can fail if the pid's have wrapped around and the old lpid is currently in use by a process that can be signaled from the the current process. But it's pretty good anyway.

That is a great idea. I just tried it and it works great. Thanks very much!