Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Update lock_file.rb indenting

  • Loading branch information...
commit 674427b105102c691dce227cd4ce86b34e1f68b3 1 parent 260bae1
Hongli Lai authored
Showing with 89 additions and 90 deletions.
  1. +89 −90 lib/daemon_controller/lock_file.rb
179 lib/daemon_controller/lock_file.rb
View
@@ -22,105 +22,104 @@
require 'fcntl'
class DaemonController
-
-# 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.
-class LockFile
- class AlreadyLocked < StandardError
- end
-
- # 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.
+ # 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).
#
- # 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.
- def initialize(filename)
- @filename = filename
- end
-
- # 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.
+ # 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.
#
- # The lock file *must* be writable, otherwise an Errno::EACCESS
- # exception will be raised.
- 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
+ # 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.
+ class LockFile
+ class AlreadyLocked < StandardError
end
- end
-
- # 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.
- 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
+
+ # 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.
+ def initialize(filename)
+ @filename = filename
end
- end
-
- # 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.
- def try_shared_lock
- File.open(@filename, 'w+') do |f|
- if Fcntl.const_defined? :F_SETFD
- f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+ # 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.
+ 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
- if f.flock(File::LOCK_SH | File::LOCK_NB)
+ end
+
+ # 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.
+ 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
- else
- raise AlreadyLocked
end
end
- end
-
- # 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.
- def try_exclusive_lock
- File.open(@filename, 'w') do |f|
- if Fcntl.const_defined? :F_SETFD
- f.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+ # 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.
+ 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
- if f.flock(File::LOCK_EX | File::LOCK_NB)
- yield
- else
- raise AlreadyLocked
+ end
+
+ # 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.
+ 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
- end
-end # class LockFile
+ end # class LockFile
end # class DaemonController
Please sign in to comment.
Something went wrong with that request. Please try again.