Class: DaemonController::LockFile

Inherits:
Object
  • Object
show all
Defined in:
lib/daemon_controller/lock_file.rb

Overview

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.

Defined Under Namespace

Classes: AlreadyLocked

Instance Method Summary collapse

Constructor Details

#initialize(filename) ⇒ LockFile

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.



51
52
53
 
# File 'lib/daemon_controller/lock_file.rb', line 51

def initialize(filename)
	@filename = filename
end

Instance Method Details

#exclusive_lock ⇒ Object

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.



62
63
64
65
66
67
68
69
70
 
# 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 ⇒ Object

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.



80
81
82
83
84
85
86
87
88
 
# 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 ⇒ Object

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.



113
114
115
116
117
118
119
120
121
122
123
124
 
# 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 ⇒ Object

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.



95
96
97
98
99
100
101
102
103
104
105
106
 
# 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