Locker.php

Go to the documentation of this file.

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

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

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)
    {
        GeneralUtility::logDeprecatedFunction();
        // 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;
    }
}