Locker.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Locking;

use TYPO3\CMS\Core\Utility\GeneralUtility;

class Locker {

    const LOCKING_METHOD_SIMPLE = 'simple';
    const LOCKING_METHOD_FLOCK = 'flock';
    const LOCKING_METHOD_SEMAPHORE = 'semaphore';
    const LOCKING_METHOD_DISABLED = 'disable';

    const FILE_LOCK_FOLDER = 'typo3temp/locks/';

    protected $method = '';

    protected $id;

    protected $resource;

    protected $filePointer;

    protected $isAcquired = FALSE;

    protected $loops = 150;

    protected $step = 200;

    protected $syslogFacility = 'cms';

    protected $isLoggingEnabled = TRUE;

    public function __construct($id, $method = self::LOCKING_METHOD_SIMPLE, $loops = 0, $step = 0) {
        // Force ID to be string
        $id = (string)$id;
        if ((int)$loops) {
            $this->loops = (int)$loops;
        }
        if ((int)$step) {
            $this->step = (int)$step;
        }
        if ($method === '' && isset($GLOBALS['TYPO3_CONF_VARS']['SYS']['lockingMode'])) {
            $method = (string)$GLOBALS['TYPO3_CONF_VARS']['SYS']['lockingMode'];
        }

        switch ($method) {
            case self::LOCKING_METHOD_SIMPLE:
                // intended fall through
            case self::LOCKING_METHOD_FLOCK:
                $this->id = md5($id);
                $this->createPathIfNeeded();
                break;
            case self::LOCKING_METHOD_SEMAPHORE:
                $this->id = abs(crc32($id));
                break;
            case self::LOCKING_METHOD_DISABLED:
                break;
            default:
                throw new \InvalidArgumentException('No such locking method "' . $method . '"', 1294586097);
        }
        $this->method = $method;
    }

    public function __destruct() {
        $this->release();
        switch ($this->method) {
            case self::LOCKING_METHOD_FLOCK:
                if (
                    GeneralUtility::isAllowedAbsPath($this->resource)
                    && GeneralUtility::isFirstPartOfStr($this->resource, PATH_site . self::FILE_LOCK_FOLDER)
                ) {
                    @unlink($this->resource);
                }
                break;
            case self::LOCKING_METHOD_SEMAPHORE:
                @sem_remove($this->resource);
                break;
            default:
                // do nothing
        }
    }

    protected function getSemaphore() {
        $this->resource = sem_get($this->id, 1);
        if ($this->resource === FALSE) {
            throw new \RuntimeException('Unable to get semaphore with id ' . $this->id, 1313828196);
        }
    }

    public function acquire() {
        // TODO refactor locking in TSFE to use the new API, then this call can be logged
        // GeneralUtility::logDeprecatedFunction();

        // Default is TRUE, which means continue without caring for other clients.
        // In the case of TYPO3s cache management, this has no negative effect except some resource overhead.
        $noWait = FALSE;
        $isAcquired = FALSE;
        switch ($this->method) {
            case self::LOCKING_METHOD_SIMPLE:
                if (file_exists($this->resource)) {
                    $this->sysLog('Waiting for a different process to release the lock');
                    $maxExecutionTime = (int)ini_get('max_execution_time');
                    $maxAge = time() - ($maxExecutionTime ?: 120);
                    if (@filectime($this->resource) < $maxAge) {
                        @unlink($this->resource);
                        $this->sysLog('Unlinking stale lockfile', GeneralUtility::SYSLOG_SEVERITY_WARNING);
                    }
                }
                for ($i = 0; $i < $this->loops; $i++) {
                    $filePointer = @fopen($this->resource, 'x');
                    if ($filePointer !== FALSE) {
                        fclose($filePointer);
                        GeneralUtility::fixPermissions($this->resource);
                        $this->sysLog('Lock acquired');
                        $noWait = $i === 0;
                        $isAcquired = TRUE;
                        break;
                    }
                    usleep($this->step * 1000);
                }
                if (!$isAcquired) {
                    throw new \RuntimeException('Lock file could not be created', 1294586098);
                }
                break;
            case self::LOCKING_METHOD_FLOCK:
                $this->filePointer = fopen($this->resource, 'c');
                if ($this->filePointer === FALSE) {
                    throw new \RuntimeException('Lock file could not be opened', 1294586099);
                }
                // Lock without blocking
                if (flock($this->filePointer, LOCK_EX | LOCK_NB)) {
                    $noWait = TRUE;
                } elseif (flock($this->filePointer, LOCK_EX)) {
                    // Lock with blocking (waiting for similar locks to become released)
                    $noWait = FALSE;
                } else {
                    throw new \RuntimeException('Could not lock file "' . $this->resource . '"', 1294586100);
                }
                $isAcquired = TRUE;
                break;
            case self::LOCKING_METHOD_SEMAPHORE:
                $this->getSemaphore();
                while (!$isAcquired) {
                    if (@sem_acquire($this->resource)) {
                        // Unfortunately it is not possible to find out if the request has blocked,
                        // as sem_acquire will block until we get the resource.
                        // So we do not set $noWait here at all
                        $isAcquired = TRUE;
                    }
                }
                break;
            case self::LOCKING_METHOD_DISABLED:
                break;
            default:
                // will never be reached
        }
        $this->isAcquired = $isAcquired;
        return $noWait;
    }

    public function acquireExclusiveLock() {
        if ($this->isAcquired) {
            return TRUE;
        }
        $this->isAcquired = FALSE;
        switch ($this->method) {
            case self::LOCKING_METHOD_SIMPLE:
                if (file_exists($this->resource)) {
                    $this->sysLog('Waiting for a different process to release the lock');
                    $maxExecutionTime = (int)ini_get('max_execution_time');
                    $maxAge = time() - ($maxExecutionTime ?: 120);
                    if (@filectime($this->resource) < $maxAge) {
                        @unlink($this->resource);
                        $this->sysLog('Unlinking stale lockfile', GeneralUtility::SYSLOG_SEVERITY_WARNING);
                    }
                }
                for ($i = 0; $i < $this->loops; $i++) {
                    $filePointer = @fopen($this->resource, 'x');
                    if ($filePointer !== FALSE) {
                        fclose($filePointer);
                        GeneralUtility::fixPermissions($this->resource);
                        $this->sysLog('Lock acquired');
                        $this->isAcquired = TRUE;
                        break;
                    }
                    usleep($this->step * 1000);
                }
                break;
            case self::LOCKING_METHOD_FLOCK:
                $this->filePointer = fopen($this->resource, 'c');
                if ($this->filePointer === FALSE) {
                    throw new \RuntimeException('Lock file could not be opened', 1294586099);
                }
                if (flock($this->filePointer, LOCK_EX)) {
                    $this->isAcquired = TRUE;
                }
                break;
            case self::LOCKING_METHOD_SEMAPHORE:
                $this->getSemaphore();
                if (@sem_acquire($this->resource)) {
                    $this->isAcquired = TRUE;
                }
                break;
            case self::LOCKING_METHOD_DISABLED:
                break;
            default:
                // will never be reached
        }
        return $this->isAcquired;
    }

    public function acquireSharedLock() {
        if ($this->isAcquired) {
            return TRUE;
        }
        if ($this->method === self::LOCKING_METHOD_FLOCK) {
            $this->filePointer = fopen($this->resource, 'c');
            if ($this->filePointer === FALSE) {
                throw new \RuntimeException('Lock file could not be opened', 1294586099);
            }
            if (flock($this->filePointer, LOCK_SH)) {
                $this->isAcquired = TRUE;
            }
        }
        return $this->isAcquired;
    }

    public function release() {
        if (!$this->isAcquired) {
            return TRUE;
        }
        $success = TRUE;
        switch ($this->method) {
            case self::LOCKING_METHOD_SIMPLE:
                if (
                    GeneralUtility::isAllowedAbsPath($this->resource)
                    && GeneralUtility::isFirstPartOfStr($this->resource, PATH_site . self::FILE_LOCK_FOLDER)
                ) {
                    if (@unlink($this->resource) === FALSE) {
                        $success = FALSE;
                    }
                }
                break;
            case self::LOCKING_METHOD_FLOCK:
                if (is_resource($this->filePointer)) {
                    if (flock($this->filePointer, LOCK_UN) === FALSE) {
                        $success = FALSE;
                    }
                    fclose($this->filePointer);
                }
                break;
            case self::LOCKING_METHOD_SEMAPHORE:
                if (!@sem_release($this->resource)) {
                    $success = FALSE;
                }
                break;
            case self::LOCKING_METHOD_DISABLED:
                break;
            default:
                // will never be reached
        }
        $this->isAcquired = FALSE;
        return $success;
    }

    public function getMethod() {
        return $this->method;
    }

    public function getId() {
        return $this->id;
    }

    public function getResource() {
        return $this->resource;
    }

    public function getLockStatus() {
        return $this->isAcquired;
    }

    public function isLocked() {
        $result = FALSE;
        switch ($this->method) {
            case self::LOCKING_METHOD_SIMPLE:
                if (file_exists($this->resource)) {
                    $maxExecutionTime = (int)ini_get('max_execution_time');
                    $maxAge = time() - ($maxExecutionTime ?: 120);
                    if (@filectime($this->resource) < $maxAge) {
                        @unlink($this->resource);
                        $this->sysLog('Unlinking stale lockfile', GeneralUtility::SYSLOG_SEVERITY_WARNING);
                    } else {
                        $result = TRUE;
                    }
                }
                break;
            case self::LOCKING_METHOD_FLOCK:
                // we can't detect this reliably here, since the third parameter of flock() does not work on windows
                break;
            case self::LOCKING_METHOD_SEMAPHORE:
                // no way to detect this at all, no PHP API for that
                break;
            case self::LOCKING_METHOD_DISABLED:
                break;
            default:
                // will never be reached
        }
        return $result;
    }

    public function setSyslogFacility($syslogFacility) {
        $this->syslogFacility = $syslogFacility;
    }

    public function setEnableLogging($isLoggingEnabled) {
        $this->isLoggingEnabled = $isLoggingEnabled;
    }

    public function sysLog($message, $severity = 0) {
        if ($this->isLoggingEnabled) {
            GeneralUtility::sysLog('Locking [' . $this->method . '::' . $this->id . ']: ' . trim($message), $this->syslogFacility, $severity);
        }
    }

    protected function createPathIfNeeded() {
        $path = PATH_site . self::FILE_LOCK_FOLDER;
        if (!is_dir($path)) {
            // Not using mkdir_deep on purpose here, if typo3temp itself
            // does not exist, this issue should be solved on a different
            // level of the application.
            if (!GeneralUtility::mkdir($path)) {
                throw new \RuntimeException('Cannot create directory ' . $path, 1395140007);
            }
        }
        if (!is_writable($path)) {
            throw new \RuntimeException('Cannot write to directory ' . $path, 1396278700);
        }
        $this->resource = $path . $this->id;
    }
}