class DaemonController::LockFile

A lock file is a synchronization mechanism, like a Mutex, but it also allows inter-process synchronization (as opposed to only inter-thread synchronization within a single process).

Processes can obtain either a shared lock or an exclusive lock. It’s possible for multiple processes to obtain a shared lock on a file as long as no exclusive lock has been obtained by a process. If a process has obtained an exclusive lock, then no other processes can lock the file, whether they’re trying to obtain a shared lock or an exclusive lock.

Note that on JRuby, LockFile can only guarantee synchronization between threads if the different threads use the same LockFile object. Specifying the same filename is not enough.

Public Class Methods

new(filename) click to toggle source

Create a LockFile object. The lock file is initially not locked.

filename may point to a nonexistant file. In that case, the lock file will not be created until one’s trying to obtain a lock.

Note that LockFile will use this exact filename. So if filename is a relative filename, then the actual lock file that will be used depends on the current working directory.

# File lib/daemon_controller/lock_file.rb, line 51
def initialize(filename)
        @filename = filename
end

Public Instance Methods

exclusive_lock() { || ... } click to toggle source

Obtain an exclusive lock on the lock file, yield the given block, then unlock the lockfile. If the lock file was already locked (whether shared or exclusively) by another process/thread then this method will block until the lock file has been unlocked.

The lock file must be writable, otherwise an Errno::EACCESS exception will be raised.

# File lib/daemon_controller/lock_file.rb, line 62
def exclusive_lock
        File.open(@filename, 'w') do |f|
                if Fcntl.const_defined? :F_SETFD
                        f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
                end
                f.flock(File::LOCK_EX)
                yield
        end
end
shared_lock() { || ... } click to toggle source

Obtain an exclusive lock on the lock file, yield the given block, then unlock the lockfile. If the lock file was already exclusively locked by another process/thread then this method will block until the exclusive lock has been released. This method will not block if only shared locks have been obtained.

The lock file must be writable, otherwise an Errno::EACCESS exception will be raised.

# File lib/daemon_controller/lock_file.rb, line 80
def shared_lock
        File.open(@filename, 'w+') do |f|
                if Fcntl.const_defined? :F_SETFD
                        f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
                end
                f.flock(File::LOCK_SH)
                yield
        end
end
try_exclusive_lock() { || ... } click to toggle source

Try to obtain an exclusive lock on the lock file, similar to exclusive_lock. But unlike exclusive_lock, this method will raise AlreadyLocked if no lock can be obtained, instead of blocking.

If a lock can be obtained, then the given block will be yielded.

# File lib/daemon_controller/lock_file.rb, line 113
def try_exclusive_lock
        File.open(@filename, 'w') do |f|
                if Fcntl.const_defined? :F_SETFD
                        f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
                end
                if f.flock(File::LOCK_EX | File::LOCK_NB)
                        yield
                else
                        raise AlreadyLocked
                end
        end
end
try_shared_lock() { || ... } click to toggle source

Try to obtain a shared lock on the lock file, similar to shared_lock. But unlike shared_lock, this method will raise AlreadyLocked if no lock can be obtained, instead of blocking.

If a lock can be obtained, then the given block will be yielded.

# File lib/daemon_controller/lock_file.rb, line 95
def try_shared_lock
        File.open(@filename, 'w+') do |f|
                if Fcntl.const_defined? :F_SETFD
                        f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
                end
                if f.flock(File::LOCK_SH | File::LOCK_NB)
                        yield
                else
                        raise AlreadyLocked
                end
        end
end