3 * Simple version of LockManager based on using FS lock files.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
21 * @ingroup LockManager
25 * Simple version of LockManager based on using FS lock files.
26 * All locks are non-blocking, which avoids deadlocks.
28 * This should work fine for small sites running off one server.
29 * Do not use this with 'lockDirectory' set to an NFS mount unless the
30 * NFS client is at least version 2.6.12. Otherwise, the BSD flock()
31 * locks will be ignored; see http://nfs.sourceforge.net/#section_d.
33 * @ingroup LockManager
36 class FSLockManager
extends LockManager
{
37 /** @var Array Mapping of lock types to the type actually used */
38 protected $lockTypeMap = array(
39 self
::LOCK_SH
=> self
::LOCK_SH
,
40 self
::LOCK_UW
=> self
::LOCK_SH
,
41 self
::LOCK_EX
=> self
::LOCK_EX
44 protected $lockDir; // global dir for all servers
46 /** @var Array Map of (locked key => lock type => lock file handle) */
47 protected $handles = array();
50 * Construct a new instance from configuration.
53 * 'lockDirectory' : Directory containing the lock files
55 * @param array $config
57 function __construct( array $config ) {
58 parent
::__construct( $config );
60 $this->lockDir
= $config['lockDirectory'];
64 * @see LockManager::doLock()
67 protected function doLock( array $paths, $type ) {
68 $status = Status
::newGood();
70 $lockedPaths = array(); // files locked in this attempt
71 foreach ( $paths as $path ) {
72 $status->merge( $this->doSingleLock( $path, $type ) );
73 if ( $status->isOK() ) {
74 $lockedPaths[] = $path;
76 // Abort and unlock everything
77 $status->merge( $this->doUnlock( $lockedPaths, $type ) );
86 * @see LockManager::doUnlock()
89 protected function doUnlock( array $paths, $type ) {
90 $status = Status
::newGood();
92 foreach ( $paths as $path ) {
93 $status->merge( $this->doSingleUnlock( $path, $type ) );
100 * Lock a single resource key
102 * @param $path string
103 * @param $type integer
106 protected function doSingleLock( $path, $type ) {
107 $status = Status
::newGood();
109 if ( isset( $this->locksHeld
[$path][$type] ) ) {
110 ++
$this->locksHeld
[$path][$type];
111 } elseif ( isset( $this->locksHeld
[$path][self
::LOCK_EX
] ) ) {
112 $this->locksHeld
[$path][$type] = 1;
114 wfSuppressWarnings();
115 $handle = fopen( $this->getLockPath( $path ), 'a+' );
117 if ( !$handle ) { // lock dir missing?
118 wfMkdirParents( $this->lockDir
);
119 $handle = fopen( $this->getLockPath( $path ), 'a+' ); // try again
122 // Either a shared or exclusive lock
123 $lock = ( $type == self
::LOCK_SH
) ? LOCK_SH
: LOCK_EX
;
124 if ( flock( $handle, $lock | LOCK_NB
) ) {
125 // Record this lock as active
126 $this->locksHeld
[$path][$type] = 1;
127 $this->handles
[$path][$type] = $handle;
130 $status->fatal( 'lockmanager-fail-acquirelock', $path );
133 $status->fatal( 'lockmanager-fail-openlock', $path );
141 * Unlock a single resource key
143 * @param $path string
144 * @param $type integer
147 protected function doSingleUnlock( $path, $type ) {
148 $status = Status
::newGood();
150 if ( !isset( $this->locksHeld
[$path] ) ) {
151 $status->warning( 'lockmanager-notlocked', $path );
152 } elseif ( !isset( $this->locksHeld
[$path][$type] ) ) {
153 $status->warning( 'lockmanager-notlocked', $path );
155 $handlesToClose = array();
156 --$this->locksHeld
[$path][$type];
157 if ( $this->locksHeld
[$path][$type] <= 0 ) {
158 unset( $this->locksHeld
[$path][$type] );
159 // If a LOCK_SH comes in while we have a LOCK_EX, we don't
160 // actually add a handler, so check for handler existence.
161 if ( isset( $this->handles
[$path][$type] ) ) {
162 if ( $type === self
::LOCK_EX
163 && isset( $this->locksHeld
[$path][self
::LOCK_SH
] )
164 && !isset( $this->handles
[$path][self
::LOCK_SH
] ) )
166 // EX lock came first: move this handle to the SH one
167 $this->handles
[$path][self
::LOCK_SH
] = $this->handles
[$path][$type];
169 // Mark this handle to be unlocked and closed
170 $handlesToClose[] = $this->handles
[$path][$type];
172 unset( $this->handles
[$path][$type] );
175 // Unlock handles to release locks and delete
176 // any lock files that end up with no locks on them...
177 if ( wfIsWindows() ) {
178 // Windows: for any process, including this one,
179 // calling unlink() on a locked file will fail
180 $status->merge( $this->closeLockHandles( $path, $handlesToClose ) );
181 $status->merge( $this->pruneKeyLockFiles( $path ) );
183 // Unix: unlink() can be used on files currently open by this
184 // process and we must do so in order to avoid race conditions
185 $status->merge( $this->pruneKeyLockFiles( $path ) );
186 $status->merge( $this->closeLockHandles( $path, $handlesToClose ) );
193 private function closeLockHandles( $path, array $handlesToClose ) {
194 $status = Status
::newGood();
195 foreach ( $handlesToClose as $handle ) {
196 if ( !flock( $handle, LOCK_UN
) ) {
197 $status->fatal( 'lockmanager-fail-releaselock', $path );
199 if ( !fclose( $handle ) ) {
200 $status->warning( 'lockmanager-fail-closelock', $path );
206 private function pruneKeyLockFiles( $path ) {
207 $status = Status
::newGood();
208 if ( !count( $this->locksHeld
[$path] ) ) {
209 # No locks are held for the lock file anymore
210 if ( !unlink( $this->getLockPath( $path ) ) ) {
211 $status->warning( 'lockmanager-fail-deletelock', $path );
213 unset( $this->locksHeld
[$path] );
214 unset( $this->handles
[$path] );
220 * Get the path to the lock file for a key
221 * @param $path string
224 protected function getLockPath( $path ) {
225 $hash = self
::sha1Base36( $path );
226 return "{$this->lockDir}/{$hash}.lock";
229 function __destruct() {
230 // Make sure remaining locks get cleared for sanity
231 foreach ( $this->locksHeld
as $path => $locks ) {
232 $this->doSingleUnlock( $path, self
::LOCK_EX
);
233 $this->doSingleUnlock( $path, self
::LOCK_SH
);