FSLockManager.php

Go to the documentation of this file.

<?php
class FSLockManager extends LockManager {
    protected $lockTypeMap = array(
        self::LOCK_SH => self::LOCK_SH,
        self::LOCK_UW => self::LOCK_SH,
        self::LOCK_EX => self::LOCK_EX
    );
 
    protected $lockDir; // global dir for all servers
 
    protected $handles = array();
 
    function __construct( array $config ) {
        parent::__construct( $config );
 
        $this->lockDir = $config['lockDirectory'];
    }
 
    protected function doLock( array $paths, $type ) {
        $status = Status::newGood();
 
        $lockedPaths = array(); // files locked in this attempt
        foreach ( $paths as $path ) {
            $status->merge( $this->doSingleLock( $path, $type ) );
            if ( $status->isOK() ) {
                $lockedPaths[] = $path;
            } else {
                // Abort and unlock everything
                $status->merge( $this->doUnlock( $lockedPaths, $type ) );
 
                return $status;
            }
        }
 
        return $status;
    }
 
    protected function doUnlock( array $paths, $type ) {
        $status = Status::newGood();
 
        foreach ( $paths as $path ) {
            $status->merge( $this->doSingleUnlock( $path, $type ) );
        }
 
        return $status;
    }
 
    protected function doSingleLock( $path, $type ) {
        $status = Status::newGood();
 
        if ( isset( $this->locksHeld[$path][$type] ) ) {
            ++$this->locksHeld[$path][$type];
        } elseif ( isset( $this->locksHeld[$path][self::LOCK_EX] ) ) {
            $this->locksHeld[$path][$type] = 1;
        } else {
            if ( isset( $this->handles[$path] ) ) {
                $handle = $this->handles[$path];
            } else {
                wfSuppressWarnings();
                $handle = fopen( $this->getLockPath( $path ), 'a+' );
                wfRestoreWarnings();
                if ( !$handle ) { // lock dir missing?
                    wfMkdirParents( $this->lockDir );
                    $handle = fopen( $this->getLockPath( $path ), 'a+' ); // try again
                }
            }
            if ( $handle ) {
                // Either a shared or exclusive lock
                $lock = ( $type == self::LOCK_SH ) ? LOCK_SH : LOCK_EX;
                if ( flock( $handle, $lock | LOCK_NB ) ) {
                    // Record this lock as active
                    $this->locksHeld[$path][$type] = 1;
                    $this->handles[$path] = $handle;
                } else {
                    fclose( $handle );
                    $status->fatal( 'lockmanager-fail-acquirelock', $path );
                }
            } else {
                $status->fatal( 'lockmanager-fail-openlock', $path );
            }
        }
 
        return $status;
    }
 
    protected function doSingleUnlock( $path, $type ) {
        $status = Status::newGood();
 
        if ( !isset( $this->locksHeld[$path] ) ) {
            $status->warning( 'lockmanager-notlocked', $path );
        } elseif ( !isset( $this->locksHeld[$path][$type] ) ) {
            $status->warning( 'lockmanager-notlocked', $path );
        } else {
            $handlesToClose = array();
            --$this->locksHeld[$path][$type];
            if ( $this->locksHeld[$path][$type] <= 0 ) {
                unset( $this->locksHeld[$path][$type] );
            }
            if ( !count( $this->locksHeld[$path] ) ) {
                unset( $this->locksHeld[$path] ); // no locks on this path
                if ( isset( $this->handles[$path] ) ) {
                    $handlesToClose[] = $this->handles[$path];
                    unset( $this->handles[$path] );
                }
            }
            // Unlock handles to release locks and delete
            // any lock files that end up with no locks on them...
            if ( wfIsWindows() ) {
                // Windows: for any process, including this one,
                // calling unlink() on a locked file will fail
                $status->merge( $this->closeLockHandles( $path, $handlesToClose ) );
                $status->merge( $this->pruneKeyLockFiles( $path ) );
            } else {
                // Unix: unlink() can be used on files currently open by this
                // process and we must do so in order to avoid race conditions
                $status->merge( $this->pruneKeyLockFiles( $path ) );
                $status->merge( $this->closeLockHandles( $path, $handlesToClose ) );
            }
        }
 
        return $status;
    }
 
    private function closeLockHandles( $path, array $handlesToClose ) {
        $status = Status::newGood();
        foreach ( $handlesToClose as $handle ) {
            if ( !flock( $handle, LOCK_UN ) ) {
                $status->fatal( 'lockmanager-fail-releaselock', $path );
            }
            if ( !fclose( $handle ) ) {
                $status->warning( 'lockmanager-fail-closelock', $path );
            }
        }
 
        return $status;
    }
 
    private function pruneKeyLockFiles( $path ) {
        $status = Status::newGood();
        if ( !isset( $this->locksHeld[$path] ) ) {
            # No locks are held for the lock file anymore
            if ( !unlink( $this->getLockPath( $path ) ) ) {
                $status->warning( 'lockmanager-fail-deletelock', $path );
            }
            unset( $this->handles[$path] );
        }
 
        return $status;
    }
 
    protected function getLockPath( $path ) {
        return "{$this->lockDir}/{$this->sha1Base36Absolute( $path )}.lock";
    }
 
    function __destruct() {
        while ( count( $this->locksHeld ) ) {
            foreach ( $this->locksHeld as $path => $locks ) {
                $this->doSingleUnlock( $path, self::LOCK_EX );
                $this->doSingleUnlock( $path, self::LOCK_SH );
            }
        }
    }
}