LockManager.php

Go to the documentation of this file.

<?php
abstract class LockManager {
    protected $lockTypeMap = array(
        self::LOCK_SH => self::LOCK_SH,
        self::LOCK_UW => self::LOCK_EX, // subclasses may use self::LOCK_SH
        self::LOCK_EX => self::LOCK_EX
    );

    protected $locksHeld = array();

    protected $domain; // string; domain (usually wiki ID)
    protected $lockTTL; // integer; maximum time locks can be held

    const LOCK_SH = 1; // shared lock (for reads)
    const LOCK_UW = 2; // shared lock (for reads used to write elsewhere)
    const LOCK_EX = 3; // exclusive lock (for writes)

    public function __construct( array $config ) {
        $this->domain = isset( $config['domain'] ) ? $config['domain'] : wfWikiID();
        if ( isset( $config['lockTTL'] ) ) {
            $this->lockTTL = max( 1, $config['lockTTL'] );
        } elseif ( PHP_SAPI === 'cli' ) {
            $this->lockTTL = 2 * 3600;
        } else {
            $met = ini_get( 'max_execution_time' ); // this is 0 in CLI mode
            $this->lockTTL = max( 5 * 60, 2 * (int)$met );
        }
    }

    final public function lock( array $paths, $type = self::LOCK_EX, $timeout = 0 ) {
        return $this->lockByType( array( $type => $paths ), $timeout );
    }

    final public function lockByType( array $pathsByType, $timeout = 0 ) {
        wfProfileIn( __METHOD__ );
        $status = Status::newGood();
        $pathsByType = $this->normalizePathsByType( $pathsByType );
        $msleep = array( 0, 50, 100, 300, 500 ); // retry backoff times
        $start = microtime( true );
        do {
            $status = $this->doLockByType( $pathsByType );
            $elapsed = microtime( true ) - $start;
            if ( $status->isOK() || $elapsed >= $timeout || $elapsed < 0 ) {
                break; // success, timeout, or clock set back
            }
            usleep( 1e3 * ( next( $msleep ) ?: 1000 ) ); // use 1 sec after enough times
            $elapsed = microtime( true ) - $start;
        } while ( $elapsed < $timeout && $elapsed >= 0 );
        wfProfileOut( __METHOD__ );
        return $status;
    }

    final public function unlock( array $paths, $type = self::LOCK_EX ) {
        return $this->unlockByType( array( $type => $paths ) );
    }

    final public function unlockByType( array $pathsByType ) {
        wfProfileIn( __METHOD__ );
        $pathsByType = $this->normalizePathsByType( $pathsByType );
        $status = $this->doUnlockByType( $pathsByType );
        wfProfileOut( __METHOD__ );
        return $status;
    }

    final protected function sha1Base36Absolute( $path ) {
        return wfBaseConvert( sha1( "{$this->domain}:{$path}" ), 16, 36, 31 );
    }

    final protected function sha1Base16Absolute( $path ) {
        return sha1( "{$this->domain}:{$path}" );
    }

    final protected function normalizePathsByType( array $pathsByType ) {
        $res = array();
        foreach ( $pathsByType as $type => $paths ) {
            $res[$this->lockTypeMap[$type]] = array_unique( $paths );
        }
        return $res;
    }

    protected function doLockByType( array $pathsByType ) {
        $status = Status::newGood();
        $lockedByType = array(); // map of (type => paths)
        foreach ( $pathsByType as $type => $paths ) {
            $status->merge( $this->doLock( $paths, $type ) );
            if ( $status->isOK() ) {
                $lockedByType[$type] = $paths;
            } else {
                // Release the subset of locks that were acquired
                foreach ( $lockedByType as $type => $paths ) {
                    $status->merge( $this->doUnlock( $paths, $type ) );
                }
                break;
            }
        }
        return $status;
    }

    abstract protected function doLock( array $paths, $type );

    protected function doUnlockByType( array $pathsByType ) {
        $status = Status::newGood();
        foreach ( $pathsByType as $type => $paths ) {
            $status->merge( $this->doUnlock( $paths, $type ) );
        }
        return $status;
    }

    abstract protected function doUnlock( array $paths, $type );
}

class NullLockManager extends LockManager {
    protected function doLock( array $paths, $type ) {
        return Status::newGood();
    }

    protected function doUnlock( array $paths, $type ) {
        return Status::newGood();
    }
}