Class: DaemonController::LockFile

### Home Classes Methods

### In Files

- lib/daemon_controller/lock_file.rb

### Parent

Object

### Namespace

- CLASS DaemonController::LockFile::AlreadyLocked

### Methods

- ::new
- #exclusive_lock
- #shared_lock
- #try_exclusive_lock
- #try_shared_lock

### Class/Module Index

Quicksearch

- DaemonController
- DaemonController::AlreadyStarted
- DaemonController::ConnectError
- DaemonController::DaemonizationTimeout
- DaemonController::Error
- DaemonController::LockFile
- DaemonController::LockFile::AlreadyLocked
- DaemonController::StartError
- DaemonController::StartTimeout
- DaemonController::StopError
- DaemonController::StopTimeout
- DaemonController::TimeoutError
- Object

No matching classes.

# 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

[Validate]

Generated with the Darkfish Rdoc Generator 2.