friendica-github/src/Core/Lock.php

<?php

/**
 * @file src/Core/Lock.php
 * @brief Functions for preventing parallel execution of functions
 */

namespace Friendica\Core;

use Friendica\Core\Cache\CacheDriverFactory;
use Friendica\Core\Cache\IMemoryCacheDriver;

/**
 * @brief This class contain Functions for preventing parallel execution of functions
 */
class Lock
{
	/**
	 * @var Lock\ILockDriver;
	 */
	static $driver = null;

	public static function init()
	{
		$lock_driver = Config::get('system', 'lock_driver', 'default');

		try {
			switch ($lock_driver) {
				case 'memcache':
				case 'memcached':
				case 'redis':
					$cache_driver = CacheDriverFactory::create($lock_driver);
					if ($cache_driver instanceof IMemoryCacheDriver) {
						self::$driver = new Lock\CacheLockDriver($cache_driver);
					}
					break;

				case 'database':
					self::$driver = new Lock\DatabaseLockDriver();
					break;

				case 'semaphore':
					self::$driver = new Lock\SemaphoreLockDriver();
					break;

				default:
					self::useAutoDriver();
			}
		} catch (\Exception $exception) {
			Logger::log('Driver \'' . $lock_driver . '\' failed - Fallback to \'useAutoDriver()\'');
			self::useAutoDriver();
		}
	}

	/**
	 * @brief This method tries to find the best - local - locking method for Friendica
	 *
	 * The following sequence will be tried:
	 * 1. Semaphore Locking
	 * 2. Cache Locking
	 * 3. Database Locking
	 *
	 */
	private static function useAutoDriver() {

		// 1. Try to use Semaphores for - local - locking
		if (function_exists('sem_get')) {
			try {
				self::$driver = new Lock\SemaphoreLockDriver();
				return;
			} catch (\Exception $exception) {
				Logger::log('Using Semaphore driver for locking failed: ' . $exception->getMessage());
			}
		}

		// 2. Try to use Cache Locking (don't use the DB-Cache Locking because it works different!)
		$cache_driver = Config::get('system', 'cache_driver', 'database');
		if ($cache_driver != 'database') {
			try {
				$lock_driver = CacheDriverFactory::create($cache_driver);
				if ($lock_driver instanceof IMemoryCacheDriver) {
					self::$driver = new Lock\CacheLockDriver($lock_driver);
				}
				return;
			} catch (\Exception $exception) {
				Logger::log('Using Cache driver for locking failed: ' . $exception->getMessage());
			}
		}

		// 3. Use Database Locking as a Fallback
		self::$driver = new Lock\DatabaseLockDriver();
	}

	/**
	 * Returns the current cache driver
	 *
	 * @return Lock\ILockDriver;
	 */
	private static function getDriver()
	{
		if (self::$driver === null) {
			self::init();
		}

		return self::$driver;
	}

	/**
	 * @brief Acquires a lock for a given name
	 *
	 * @param string  $key Name of the lock
	 * @param integer $timeout Seconds until we give up
	 * @param integer $ttl The Lock lifespan, must be one of the Cache constants
	 *
	 * @return boolean Was the lock successful?
	 */
	public static function acquire($key, $timeout = 120, $ttl = Cache::FIVE_MINUTES)
	{
		return self::getDriver()->acquireLock($key, $timeout, $ttl);
	}

	/**
	 * @brief Releases a lock if it was set by us
	 *
	 * @param string $key   Name of the lock
	 * @param bool   $force Force the lock to get releases
	 * @return void
	 */
	public static function release($key, $force = false)
	{
		self::getDriver()->releaseLock($key, $force);
	}

	/**
	 * @brief Releases all lock that were set by us
	 * @return void
	 */
	public static function releaseAll()
	{
		self::getDriver()->releaseAll();
	}
}