CODEWITHSUNDEEP
rubylinux
Jason Butler
Jason Butler

Reputation: 5649

How do I ensure only one instance of a Ruby script is running at a time?

I have a process that runs on cron every five minutes. Usually, it takes only a few seconds to run, but sometimes it takes several minutes. I want to ensure that only one version of this is running at a time.

I tried an obvious way...

File.open("/tmp/indexer_lock.tmp",'w') do |f|
  exit unless f.flock(File::LOCK_EX)
end

...but it's not testing to see if it can get the lock, it's blocking until the lock is released.

Any idea what I'm missing? I'd rather not hack something using ps, but that's an alternative.

Upvotes: 9

Views: 5916

Answers (10)

wjordan
wjordan

Reputation: 20380

Here's a one-liner that should work at the top of any Ruby script:

exit unless File.new(__FILE__)).tap {|f| f.autoclose = false}.flock(File::LOCK_NB | File::LOCK_EX)

There are two issues with the original code.

First, the reason it's blocking is that the call to #flock is missing File::LOCK_NB:

Don't block when locking. May be combined with other lock options using logical or.

Second, if a File object is closed (whether at the end of an #open block as in the code above, via explicit #close, or implicitly auto-closed when the File is garbage-collected), the underlying file descriptor is closed and the lock is released. To prevent this you can set #autoclose =false.

Upvotes: 3

Matt Todd
Matt Todd

Reputation: 817

Depending on your needs, this should work just fine and doesn't require creating another file anywhere.

exit unless DATA.flock(File::LOCK_NB | File::LOCK_EX)

# your script here

__END__
DO NOT REMOVE: required for the DATA object above.

Upvotes: 5

smathy
smathy

Reputation: 27961

I know this is old, but for anyone interested, there's a non-blocking constant that you can pass to flock so that it returns instead of blocking.

File.new("/tmp/foo.lock").flock( File::LOCK_NB | File::LOCK_EX )

Update for slhck

flock will return true if this process received the lock, false otherwise. So to ensure just one process is running at a time you just want to try to get the lock, and exit if you weren't able to. It's as simple as putting an exit unless in front of the line of code I have above:

exit unless File.new("/tmp/foo.lock").flock( File::LOCK_NB | File::LOCK_EX )

Upvotes: 24

Seamus Abshere
Seamus Abshere

Reputation: 8516

At a higher level, you might find the lock_method gem useful:

def the_method_my_cron_job_calls
  # something really expensive
end
lock_method :the_method_my_cron_job_calls

It uses lockfiles stored on the local filesystem (what was being discussed above) by default, but you can also configure remote lock storage:

LockMethod.config.storage = Redis.new([...]) # a remote RedisToGo instance, perhaps?

Also...

def the_method_my_cron_job_calls
  # something really expensive
end
lock_method :the_method_my_cron_job_calls, (60*60) # automatically expire lock after an hour

Upvotes: 0

Sarah Mei
Sarah Mei

Reputation: 18484

There's a lockfile gem for exactly this situation. I've used it before and it's dead simple.

Upvotes: 3

MarkR
MarkR

Reputation: 63538

Can you not add File::LOCK_NB to your lock, to make it non-blocking (i.e. it fails if it can't get the lock)

That would work in C, Perl etc.

Upvotes: 0

pisswillis
pisswillis

Reputation: 1589

If your using cron it might be easier to do something like this in the shell script that cron calls:

#!/usr/local/bin/bash
#

if ps -C $PROGRAM_NAME &> /dev/null ; then
   : #Program is already running.. appropriate action can be performed here (kill it?)
else
   #Program is not running.. launch it.
   $PROGRAM_NAME
fi

Upvotes: 2

ucron
ucron

Reputation: 2852

Although this isn't directly answering your question, if I were you I'd probably write a daemon script (you could use http://daemons.rubyforge.org/)

You could have your indexer (assuming its indexer.rb) be run through a wrapper script named script/index for example:

require 'rubygems'
require 'daemons'

Daemons.run('indexer.rb')

And your indexer can do almost the same thing, except you specify a sleep interval 

loop do
   # code executing your indexing 

   sleep INDEXING_INTERVAL
end

This is how job processors in tandem with a queue server usually function.

Upvotes: 3

Jason Butler
Jason Butler

Reputation: 5649

Ok, working off notes from @shodanex's pointer, here's what I have. I rubied it up a little bit (though I don't know of a touch analogue in Ruby).

tmp_file = File.expand_path(File.dirname(__FILE__)) +  "/indexer.lock"
if File.exists?(tmp_file)
  puts "quitting"
  exit
else
  `touch #{tmp_file}`
end

.. do stuff ..

File.delete(tmp_file)

Upvotes: 1

shodanex
shodanex

Reputation: 15406

You could create and delete a temporary file and check for existence of this file. Please check the answer to this question : one instance shell script

Upvotes: 3

Related Questions