Parent

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
51:         def initialize(filename)
52:                 @filename = filename
53:         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
62:         def exclusive_lock
63:                 File.open(@filename, 'w') do |f|
64:                         if Fcntl.const_defined? :F_SETFD
65:                                 f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
66:                         end
67:                         f.flock(File::LOCK_EX)
68:                         yield
69:                 end
70:         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
80:         def shared_lock
81:                 File.open(@filename, 'w') do |f|
82:                         if Fcntl.const_defined? :F_SETFD
83:                                 f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
84:                         end
85:                         f.flock(File::LOCK_SH)
86:                         yield
87:                 end
88:         end
try_exclusive_lock() click to toggle source

Try to obtain an exclusive lock on the lock file, similar to #. But unlike #, 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
113:         def try_exclusive_lock
114:                 File.open(@filename, 'w') do |f|
115:                         if Fcntl.const_defined? :F_SETFD
116:                                 f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
117:                         end
118:                         if f.flock(File::LOCK_EX | File::LOCK_NB)
119:                                 yield
120:                         else
121:                                 raise AlreadyLocked
122:                         end
123:                 end
124:         end
try_shared_lock() click to toggle source

Try to obtain a shared lock on the lock file, similar to #. But unlike #, 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
 95:         def try_shared_lock
 96:                 File.open(@filename, 'w') do |f|
 97:                         if Fcntl.const_defined? :F_SETFD
 98:                                 f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 99:                         end
100:                         if f.flock(File::LOCK_SH | File::LOCK_NB)
101:                                 yield
102:                         else
103:                                 raise AlreadyLocked
104:                         end
105:                 end
106:         end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.