Browse Source

Refactor Cache/Lock to DICE

- Refactor Cache classes
- Refactor Lock classes
- Improved test speed (removed some seperate class annotations)
pull/7465/head
Philipp Holzer 2 years ago
parent
commit
d56bd28a07
No known key found for this signature in database GPG Key ID: D8365C3D36B77D90
  1. 40
      src/Console/Cache.php
  2. 81
      src/Core/Cache.php
  3. 4
      src/Core/Cache/APCuCache.php
  4. 19
      src/Core/Cache/AbstractCacheDriver.php
  5. 1
      src/Core/Cache/ArrayCache.php
  6. 32
      src/Core/Cache/DatabaseCacheDriver.php
  7. 14
      src/Core/Cache/ICacheDriver.php
  8. 5
      src/Core/Cache/IMemoryCacheDriver.php
  9. 13
      src/Core/Cache/MemcacheCacheDriver.php
  10. 23
      src/Core/Cache/MemcachedCacheDriver.php
  11. 155
      src/Core/Cache/ProfilerCache.php
  12. 14
      src/Core/Cache/RedisCacheDriver.php
  13. 115
      src/Core/Lock.php
  14. 4
      src/Core/Lock/AbstractLockDriver.php
  15. 14
      src/Core/Lock/CacheLockDriver.php
  16. 32
      src/Core/Lock/DatabaseLockDriver.php
  17. 12
      src/Core/Lock/ILockDriver.php
  18. 82
      src/Factory/CacheDriverFactory.php
  19. 128
      src/Factory/LockDriverFactory.php
  20. 17
      static/dependencies.config.php
  21. 48
      tests/DatabaseTest.php
  22. 58
      tests/DatabaseTestTrait.php
  23. 10
      tests/Util/DbaCacheMockTrait.php
  24. 1
      tests/Util/VFSTrait.php
  25. 2
      tests/src/Core/Cache/APCuCacheDriverTest.php
  26. 2
      tests/src/Core/Cache/ArrayCacheDriverTest.php
  27. 34
      tests/src/Core/Cache/CacheTest.php
  28. 139
      tests/src/Core/Cache/DatabaseCacheDriverTest.php
  29. 14
      tests/src/Core/Cache/MemcacheCacheDriverTest.php
  30. 12
      tests/src/Core/Cache/MemcachedCacheDriverTest.php
  31. 24
      tests/src/Core/Cache/MemoryCacheTest.php
  32. 19
      tests/src/Core/Cache/RedisCacheDriverTest.php
  33. 3
      tests/src/Core/Lock/APCuCacheLockDriverTest.php
  34. 3
      tests/src/Core/Lock/ArrayCacheLockDriverTest.php
  35. 113
      tests/src/Core/Lock/DatabaseLockDriverTest.php
  36. 38
      tests/src/Core/Lock/LockTest.php
  37. 12
      tests/src/Core/Lock/MemcacheCacheLockDriverTest.php
  38. 12
      tests/src/Core/Lock/MemcachedCacheLockDriverTest.php
  39. 19
      tests/src/Core/Lock/RedisCacheLockDriverTest.php
  40. 19
      tests/src/Core/Lock/SemaphoreLockDriverTest.php

40
src/Console/Cache.php

@ -4,7 +4,9 @@ namespace Friendica\Console;
use Asika\SimpleConsole\CommandArgsException;
use Friendica\App;
use Friendica\Core;
use Friendica\Core\Cache\ICacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Factory\CacheDriverFactory;
use RuntimeException;
/**
@ -25,6 +27,16 @@ class Cache extends \Asika\SimpleConsole\Console
*/
private $appMode;
/**
* @var string The cache driver name
*/
private $cacheDriverName;
/**
* @var ICacheDriver
*/
private $cache;
protected function getHelp()
{
$help = <<<HELP
@ -59,11 +71,13 @@ HELP;
return $help;
}
public function __construct(App\Mode $appMode, array $argv = null)
public function __construct(App\Mode $appMode, Configuration $config, ICacheDriver $cache, array $argv = null)
{
parent::__construct($argv);
$this->appMode = $appMode;
$this->cache = $cache;
$this->cacheDriverName = $config->get('system', 'cache_driver', CacheDriverFactory::DEFAULT_DRIVER);
}
protected function doExecute()
@ -79,11 +93,9 @@ HELP;
$this->out('Database isn\'t ready or populated yet, database cache won\'t be available');
}
Core\Cache::init();
if ($this->getOption('v')) {
$this->out('Cache Driver Name: ' . Core\Cache::$driver_name);
$this->out('Cache Driver Class: ' . Core\Cache::$driver_class);
$this->out('Cache Driver Name: ' . $this->cacheDriverName);
$this->out('Cache Driver Class: ' . get_class($this->cache));
}
switch ($this->getArgument(0)) {
@ -115,7 +127,7 @@ HELP;
private function executeList()
{
$prefix = $this->getArgument(1);
$keys = Core\Cache::getAllKeys($prefix);
$keys = $this->cache->getAllKeys($prefix);
if (empty($prefix)) {
$this->out('Listing all cache keys:');
@ -136,7 +148,7 @@ HELP;
{
if (count($this->args) >= 2) {
$key = $this->getArgument(1);
$value = Core\Cache::get($key);
$value = $this->cache->get($key);
$this->out("{$key} => " . var_export($value, true));
} else {
@ -149,15 +161,15 @@ HELP;
if (count($this->args) >= 3) {
$key = $this->getArgument(1);
$value = $this->getArgument(2);
$duration = intval($this->getArgument(3, Core\Cache::FIVE_MINUTES));
$duration = intval($this->getArgument(3, ICacheDriver::FIVE_MINUTES));
if (is_array(Core\Cache::get($key))) {
if (is_array($this->cache->get($key))) {
throw new RuntimeException("$key is an array and can't be set using this command.");
}
$result = Core\Cache::set($key, $value, $duration);
$result = $this->cache->set($key, $value, $duration);
if ($result) {
$this->out("{$key} <= " . Core\Cache::get($key));
$this->out("{$key} <= " . $this->cache->get($key));
} else {
$this->out("Unable to set {$key}");
}
@ -168,7 +180,7 @@ HELP;
private function executeFlush()
{
$result = Core\Cache::clear();
$result = $this->cache->clear();
if ($result) {
$this->out('Cache successfully flushed');
} else {
@ -178,7 +190,7 @@ HELP;
private function executeClear()
{
$result = Core\Cache::clear(false);
$result = $this->cache->clear(false);
if ($result) {
$this->out('Cache successfully cleared');
} else {

81
src/Core/Cache.php

@ -4,51 +4,33 @@
*/
namespace Friendica\Core;
use Friendica\Factory\CacheDriverFactory;
use Friendica\BaseObject;
use Friendica\Core\Cache\ICacheDriver;
/**
* @brief Class for storing data for a short time
*/
class Cache extends \Friendica\BaseObject
class Cache extends BaseObject
{
const MONTH = 2592000;
/** @deprecated Use ICacheDriver::MONTH */
const MONTH = ICacheDriver::MONTH;
/** @deprecated Use ICacheDriver::WEEK */
const WEEK = 604800;
/** @deprecated Use ICacheDriver::DAY */
const DAY = 86400;
/** @deprecated Use ICacheDriver::HOUR */
const HOUR = 3600;
/** @deprecated Use ICacheDriver::HALF_HOUR */
const HALF_HOUR = 1800;
/** @deprecated Use ICacheDriver::QUARTER_HOUR */
const QUARTER_HOUR = 900;
/** @deprecated Use ICacheDriver::FIVE_MINUTES */
const FIVE_MINUTES = 300;
/** @deprecated Use ICacheDriver::MINUTE */
const MINUTE = 60;
/** @deprecated Use ICacheDriver::INFINITE */
const INFINITE = 0;
/**
* @var Cache\ICacheDriver
*/
private static $driver = null;
public static $driver_class = null;
public static $driver_name = null;
public static function init()
{
self::$driver_name = Config::get('system', 'cache_driver', 'database');
self::$driver = CacheDriverFactory::create(self::$driver_name);
self::$driver_class = get_class(self::$driver);
}
/**
* Returns the current cache driver
*
* @return Cache\ICacheDriver
*/
private static function getDriver()
{
if (self::$driver === null) {
self::init();
}
return self::$driver;
}
/**
* @brief Returns all the cache keys sorted alphabetically
*
@ -59,13 +41,7 @@ class Cache extends \Friendica\BaseObject
*/
public static function getAllKeys($prefix = null)
{
$time = microtime(true);
$return = self::getDriver()->getAllKeys($prefix);
self::getApp()->getProfiler()->saveTimestamp($time, 'cache', System::callstack());
return $return;
return self::getClass(ICacheDriver::class)->getAllKeys($prefix);
}
/**
@ -78,13 +54,7 @@ class Cache extends \Friendica\BaseObject
*/
public static function get($key)
{
$time = microtime(true);
$return = self::getDriver()->get($key);
self::getApp()->getProfiler()->saveTimestamp($time, 'cache', System::callstack());
return $return;
return self::getClass(ICacheDriver::class)->get($key);
}
/**
@ -99,15 +69,9 @@ class Cache extends \Friendica\BaseObject
* @return bool
* @throws \Exception
*/
public static function set($key, $value, $duration = self::MONTH)
public static function set($key, $value, $duration = ICacheDriver::MONTH)
{
$time = microtime(true);
$return = self::getDriver()->set($key, $value, $duration);
self::getApp()->getProfiler()->saveTimestamp($time, 'cache_write', System::callstack());
return $return;
return self::getClass(ICacheDriver::class)->set($key, $value, $duration);
}
/**
@ -120,13 +84,7 @@ class Cache extends \Friendica\BaseObject
*/
public static function delete($key)
{
$time = microtime(true);
$return = self::getDriver()->delete($key);
self::getApp()->getProfiler()->saveTimestamp($time, 'cache_write', System::callstack());
return $return;
return self::getClass(ICacheDriver::class)->delete($key);
}
/**
@ -135,9 +93,10 @@ class Cache extends \Friendica\BaseObject
* @param boolean $outdated just remove outdated values
*
* @return bool
* @throws \Exception
*/
public static function clear($outdated = true)
{
return self::getDriver()->clear($outdated);
return self::getClass(ICacheDriver::class)->clear($outdated);
}
}

4
src/Core/Cache/APCuCache.php

@ -18,11 +18,13 @@ class APCuCache extends AbstractCacheDriver implements IMemoryCacheDriver
/**
* @throws Exception
*/
public function __construct()
public function __construct(string $hostname)
{
if (!self::isAvailable()) {
throw new Exception('APCu is not available.');
}
parent::__construct($hostname);
}
/**

19
src/Core/Cache/AbstractCacheDriver.php

@ -1,8 +1,6 @@
<?php
namespace Friendica\Core\Cache;
use Friendica\BaseObject;
/**
* Abstract class for common used functions
@ -11,8 +9,18 @@ use Friendica\BaseObject;
*
* @package Friendica\Core\Cache
*/
abstract class AbstractCacheDriver extends BaseObject
abstract class AbstractCacheDriver implements ICacheDriver
{
/**
* @var string The hostname
*/
private $hostName;
public function __construct(string $hostName)
{
$this->hostName = $hostName;
}
/**
* Returns the prefix (to avoid namespace conflicts)
*
@ -22,7 +30,7 @@ abstract class AbstractCacheDriver extends BaseObject
protected function getPrefix()
{
// We fetch with the hostname as key to avoid problems with other applications
return self::getApp()->getHostName();
return $this->hostName;
}
/**
@ -46,7 +54,7 @@ abstract class AbstractCacheDriver extends BaseObject
} else {
// Keys are prefixed with the node hostname, let's remove it
array_walk($keys, function (&$value) {
$value = preg_replace('/^' . self::getApp()->getHostName() . ':/', '', $value);
$value = preg_replace('/^' . $this->hostName . ':/', '', $value);
});
sort($keys);
@ -79,6 +87,5 @@ abstract class AbstractCacheDriver extends BaseObject
return $result;
}
}
}

1
src/Core/Cache/ArrayCache.php

@ -2,7 +2,6 @@
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
/**

32
src/Core/Cache/DatabaseCacheDriver.php

@ -3,7 +3,7 @@
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
use Friendica\Database\DBA;
use Friendica\Database\Database;
use Friendica\Util\DateTimeFormat;
/**
@ -13,6 +13,18 @@ use Friendica\Util\DateTimeFormat;
*/
class DatabaseCacheDriver extends AbstractCacheDriver implements ICacheDriver
{
/**
* @var Database
*/
private $dba;
public function __construct(string $hostname, Database $dba)
{
parent::__construct($hostname);
$this->dba = $dba;
}
/**
* (@inheritdoc)
*/
@ -24,13 +36,13 @@ class DatabaseCacheDriver extends AbstractCacheDriver implements ICacheDriver
$where = ['`expires` >= ? AND `k` LIKE CONCAT(?, \'%\')', DateTimeFormat::utcNow(), $prefix];
}
$stmt = DBA::select('cache', ['k'], $where);
$stmt = $this->dba->select('cache', ['k'], $where);
$keys = [];
while ($key = DBA::fetch($stmt)) {
while ($key = $this->dba->fetch($stmt)) {
array_push($keys, $key['k']);
}
DBA::close($stmt);
$this->dba->close($stmt);
return $keys;
}
@ -40,9 +52,9 @@ class DatabaseCacheDriver extends AbstractCacheDriver implements ICacheDriver
*/
public function get($key)
{
$cache = DBA::selectFirst('cache', ['v'], ['`k` = ? AND (`expires` >= ? OR `expires` = -1)', $key, DateTimeFormat::utcNow()]);
$cache = $this->dba->selectFirst('cache', ['v'], ['`k` = ? AND (`expires` >= ? OR `expires` = -1)', $key, DateTimeFormat::utcNow()]);
if (DBA::isResult($cache)) {
if ($this->dba->isResult($cache)) {
$cached = $cache['v'];
$value = @unserialize($cached);
@ -76,7 +88,7 @@ class DatabaseCacheDriver extends AbstractCacheDriver implements ICacheDriver
];
}
return DBA::update('cache', $fields, ['k' => $key], true);
return $this->dba->update('cache', $fields, ['k' => $key], true);
}
/**
@ -84,7 +96,7 @@ class DatabaseCacheDriver extends AbstractCacheDriver implements ICacheDriver
*/
public function delete($key)
{
return DBA::delete('cache', ['k' => $key]);
return $this->dba->delete('cache', ['k' => $key]);
}
/**
@ -93,9 +105,9 @@ class DatabaseCacheDriver extends AbstractCacheDriver implements ICacheDriver
public function clear($outdated = true)
{
if ($outdated) {
return DBA::delete('cache', ['`expires` < NOW()']);
return $this->dba->delete('cache', ['`expires` < NOW()']);
} else {
return DBA::delete('cache', ['`k` IS NOT NULL ']);
return $this->dba->delete('cache', ['`k` IS NOT NULL ']);
}
}
}

14
src/Core/Cache/ICacheDriver.php

@ -2,8 +2,6 @@
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
/**
* Cache Driver Interface
*
@ -11,6 +9,16 @@ use Friendica\Core\Cache;
*/
interface ICacheDriver
{
const MONTH = 2592000;
const WEEK = 604800;
const DAY = 86400;
const HOUR = 3600;
const HALF_HOUR = 1800;
const QUARTER_HOUR = 900;
const FIVE_MINUTES = 300;
const MINUTE = 60;
const INFINITE = 0;
/**
* Lists all cache keys
*
@ -38,7 +46,7 @@ interface ICacheDriver
*
* @return bool
*/
public function set($key, $value, $ttl = Cache::FIVE_MINUTES);
public function set($key, $value, $ttl = self::FIVE_MINUTES);
/**
* Delete a key from the cache

5
src/Core/Cache/IMemoryCacheDriver.php

@ -1,7 +1,6 @@
<?php
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
/**
* This interface defines methods for Memory-Caches only
@ -20,7 +19,7 @@ interface IMemoryCacheDriver extends ICacheDriver
* @param int $ttl The cache lifespan, must be one of the Cache constants
* @return bool
*/
public function add($key, $value, $ttl = Cache::FIVE_MINUTES);
public function add($key, $value, $ttl = ICacheDriver::FIVE_MINUTES);
/**
* Compares if the old value is set and sets the new value
@ -32,7 +31,7 @@ interface IMemoryCacheDriver extends ICacheDriver
*
* @return bool
*/
public function compareSet($key, $oldValue, $newValue, $ttl = Cache::FIVE_MINUTES);
public function compareSet($key, $oldValue, $newValue, $ttl = ICacheDriver::FIVE_MINUTES);
/**
* Compares if the old value is set and removes it

13
src/Core/Cache/MemcacheCacheDriver.php

@ -2,9 +2,9 @@
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
use Exception;
use Friendica\Core\Cache;
use Friendica\Core\Config\Configuration;
use Memcache;
/**
@ -23,18 +23,21 @@ class MemcacheCacheDriver extends AbstractCacheDriver implements IMemoryCacheDri
private $memcache;
/**
* @param string $memcache_host
* @param int $memcache_port
* @throws Exception
*/
public function __construct($memcache_host, $memcache_port)
public function __construct(string $hostname, Configuration $config)
{
if (!class_exists('Memcache', false)) {
throw new Exception('Memcache class isn\'t available');
}
parent::__construct($hostname);
$this->memcache = new Memcache();
$memcache_host = $config->get('system', 'memcache_host');
$memcache_port = $config->get('system', 'memcache_port');
if (!$this->memcache->connect($memcache_host, $memcache_port)) {
throw new Exception('Expected Memcache server at ' . $memcache_host . ':' . $memcache_port . ' isn\'t available');
}

23
src/Core/Cache/MemcachedCacheDriver.php

@ -2,11 +2,11 @@
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
use Friendica\Core\Logger;
use Exception;
use Friendica\Core\Cache;
use Friendica\Core\Config\Configuration;
use Memcached;
use Psr\Log\LoggerInterface;
/**
* Memcached Cache Driver
@ -23,6 +23,11 @@ class MemcachedCacheDriver extends AbstractCacheDriver implements IMemoryCacheDr
*/
private $memcached;
/**
* @var LoggerInterface
*/
private $logger;
/**
* Due to limitations of the INI format, the expected configuration for Memcached servers is the following:
* array {
@ -33,14 +38,20 @@ class MemcachedCacheDriver extends AbstractCacheDriver implements IMemoryCacheDr
* @param array $memcached_hosts
* @throws \Exception
*/
public function __construct(array $memcached_hosts)
public function __construct(string $hostname, Configuration $config, LoggerInterface $logger)
{
if (!class_exists('Memcached', false)) {
throw new Exception('Memcached class isn\'t available');
}
parent::__construct($hostname);
$this->logger = $logger;
$this->memcached = new Memcached();
$memcached_hosts = $config->get('system', 'memcached_hosts');
array_walk($memcached_hosts, function (&$value) {
if (is_string($value)) {
$value = array_map('trim', explode(',', $value));
@ -64,7 +75,7 @@ class MemcachedCacheDriver extends AbstractCacheDriver implements IMemoryCacheDr
if ($this->memcached->getResultCode() == Memcached::RES_SUCCESS) {
return $this->filterArrayKeysByPrefix($keys, $prefix);
} else {
Logger::log('Memcached \'getAllKeys\' failed with ' . $this->memcached->getResultMessage(), Logger::ALL);
$this->logger->debug('Memcached \'getAllKeys\' failed', ['result' => $this->memcached->getResultMessage()]);
return [];
}
}
@ -83,7 +94,7 @@ class MemcachedCacheDriver extends AbstractCacheDriver implements IMemoryCacheDr
if ($this->memcached->getResultCode() === Memcached::RES_SUCCESS) {
$return = $value;
} else {
Logger::log('Memcached \'get\' failed with ' . $this->memcached->getResultMessage(), Logger::ALL);
$this->logger->debug('Memcached \'get\' failed', ['result' => $this->memcached->getResultMessage()]);
}
return $return;

155
src/Core/Cache/ProfilerCache.php

@ -0,0 +1,155 @@
<?php
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
use Friendica\Core\System;
use Friendica\Util\Profiler;
/**
* This class wraps cache driver so they can get profiled - in case the profiler is enabled
*
* It is using the decorator pattern (@see
*/
class ProfilerCache implements ICacheDriver, IMemoryCacheDriver
{
/**
* @var ICacheDriver The original cache driver
*/
private $cache;
/**
* @var Profiler The profiler of Friendica
*/
private $profiler;
public function __construct(ICacheDriver $cache, Profiler $profiler)
{
$this->cache = $cache;
$this->profiler = $profiler;
}
/**
* {@inheritDoc}
*/
public function getAllKeys($prefix = null)
{
$time = microtime(true);
$return = $this->cache->getAllKeys($prefix);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
}
/**
* {@inheritDoc}
*/
public function get($key)
{
$time = microtime(true);
$return = $this->cache->get($key);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
}
/**
* {@inheritDoc}
*/
public function set($key, $value, $ttl = Cache::FIVE_MINUTES)
{
$time = microtime(true);
$return = $this->cache->set($key, $value, $ttl);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
}
/**
* {@inheritDoc}
*/
public function delete($key)
{
$time = microtime(true);
$return = $this->cache->delete($key);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
}
/**
* {@inheritDoc}
*/
public function clear($outdated = true)
{
$time = microtime(true);
$return = $this->cache->clear($outdated);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
}
/**
* {@inheritDoc}
*/
public function add($key, $value, $ttl = Cache::FIVE_MINUTES)
{
if ($this->cache instanceof IMemoryCacheDriver) {
$time = microtime(true);
$return = $this->cache->add($key, $value, $ttl);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
} else {
return false;
}
}
/**
* {@inheritDoc}
*/
public function compareSet($key, $oldValue, $newValue, $ttl = Cache::FIVE_MINUTES)
{
if ($this->cache instanceof IMemoryCacheDriver) {
$time = microtime(true);
$return = $this->cache->compareSet($key, $oldValue, $newValue, $ttl);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
} else {
return false;
}
}
/**
* {@inheritDoc}
*/
public function compareDelete($key, $value)
{
if ($this->cache instanceof IMemoryCacheDriver) {
$time = microtime(true);
$return = $this->cache->compareDelete($key, $value);
$this->profiler->saveTimestamp($time, 'cache', System::callstack());
return $return;
} else {
return false;
}
}
}

14
src/Core/Cache/RedisCacheDriver.php

@ -4,6 +4,7 @@ namespace Friendica\Core\Cache;
use Exception;
use Friendica\Core\Cache;
use Friendica\Core\Config\Configuration;
use Redis;
/**
@ -20,20 +21,23 @@ class RedisCacheDriver extends AbstractCacheDriver implements IMemoryCacheDriver
private $redis;
/**
* @param string $redis_host
* @param int $redis_port
* @param int $redis_db (Default = 0, maximum is 15)
* @param string? $redis_pw
* @throws Exception
*/
public function __construct($redis_host, $redis_port, $redis_db = 0, $redis_pw = null)
public function __construct(string $hostname, Configuration $config)
{
if (!class_exists('Redis', false)) {
throw new Exception('Redis class isn\'t available');
}
parent::__construct($hostname);
$this->redis = new Redis();
$redis_host = $config->get('system', 'redis_host');
$redis_port = $config->get('system', 'redis_port');
$redis_pw = $config->get('system', 'redis_password');
$redis_db = $config->get('system', 'redis_db', 0);
if (!$this->redis->connect($redis_host, $redis_port)) {
throw new Exception('Expected Redis server at ' . $redis_host . ':' . $redis_port . ' isn\'t available');
}

115
src/Core/Lock.php

@ -7,116 +7,28 @@
namespace Friendica\Core;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\IMemoryCacheDriver;
use Friendica\BaseObject;
use Friendica\Core\Cache\ICacheDriver;
use Friendica\Core\Lock\ILockDriver;
/**
* @brief This class contain Functions for preventing parallel execution of functions
* This class contain Functions for preventing parallel execution of functions
*/
class Lock
class Lock extends BaseObject
{
/**
* @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 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
* @param integer $ttl The Lock lifespan, must be one of the Cache constants
*
* @return boolean Was the lock successful?
* @throws \Exception
*/
public static function acquire($key, $timeout = 120, $ttl = Cache::FIVE_MINUTES)
public static function acquire($key, $timeout = 120, $ttl = ICacheDriver::FIVE_MINUTES)
{
return self::getDriver()->acquireLock($key, $timeout, $ttl);
return self::getClass(ILockDriver::class)->acquireLock($key, $timeout, $ttl);
}
/**
@ -124,19 +36,22 @@ class Lock
*
* @param string $key Name of the lock
* @param bool $override Overrides the lock to get releases
*
* @return void
* @throws \Exception
*/
public static function release($key, $override = false)
{
self::getDriver()->releaseLock($key, $override);
return self::getClass(ILockDriver::class)->releaseLock($key, $override);
}
/**
* @brief Releases all lock that were set by us
* @return void
* @throws \Exception
*/
public static function releaseAll()
{
self::getDriver()->releaseAll();
self::getClass(ILockDriver::class)->releaseAll();
}
}

4
src/Core/Lock/AbstractLockDriver.php

@ -1,7 +1,6 @@
<?php
namespace Friendica\Core\Lock;
use Friendica\BaseObject;
/**
* Class AbstractLockDriver
@ -10,7 +9,7 @@ use Friendica\BaseObject;
*
* Basic class for Locking with common functions (local acquired locks, releaseAll, ..)
*/
abstract class AbstractLockDriver extends BaseObject implements ILockDriver
abstract class AbstractLockDriver implements ILockDriver
{
/**
* @var array The local acquired locks
@ -21,6 +20,7 @@ abstract class AbstractLockDriver extends BaseObject implements ILockDriver
* Check if we've locally acquired a lock
*
* @param string key The Name of the lock
*
* @return bool Returns true if the lock is set
*/
protected function hasAcquiredLock($key)

14
src/Core/Lock/CacheLockDriver.php

@ -28,7 +28,7 @@ class CacheLockDriver extends AbstractLockDriver
public function acquireLock($key, $timeout = 120, $ttl = Cache::FIVE_MINUTES)
{
$got_lock = false;
$start = time();
$start = time();
$cachekey = self::getLockKey($key);
@ -65,8 +65,6 @@ class CacheLockDriver extends AbstractLockDriver
{
$cachekey = self::getLockKey($key);
$return = false;
if ($override) {
$return = $this->cache->delete($cachekey);
} else {
@ -83,15 +81,17 @@ class CacheLockDriver extends AbstractLockDriver
public function isLocked($key)
{
$cachekey = self::getLockKey($key);
$lock = $this->cache->get($cachekey);
$lock = $this->cache->get($cachekey);
return isset($lock) && ($lock !== false);
}
/**
* @param string $key The original key
* @return string The cache key used for the cache
* @param string $key The original key
*
* @return string The cache key used for the cache
*/
private static function getLockKey($key) {
private static function getLockKey($key)
{
return "lock:" . $key;
}
}

32
src/Core/Lock/DatabaseLockDriver.php

@ -3,7 +3,7 @@
namespace Friendica\Core\Lock;
use Friendica\Core\Cache;
use Friendica\Database\DBA;
use Friendica\Database\Database;
use Friendica\Util\DateTimeFormat;
/**
@ -18,11 +18,17 @@ class DatabaseLockDriver extends AbstractLockDriver
*/
private $pid;
/**
* @var Database The database connection of Friendica
*/
private $dba;
/**
* @param null|int $pid The Id of the current process (null means determine automatically)
*/
public function __construct($pid = null)
public function __construct(Database $dba, $pid = null)
{
$this->dba = $dba;
$this->pid = isset($pid) ? $pid : getmypid();
}
@ -32,13 +38,13 @@ class DatabaseLockDriver extends AbstractLockDriver
public function acquireLock($key, $timeout = 120, $ttl = Cache::FIVE_MINUTES)
{
$got_lock = false;
$start = time();
$start = time();
do {
DBA::lock('locks');
$lock = DBA::selectFirst('locks', ['locked', 'pid'], ['`name` = ? AND `expires` >= ?', $key, DateTimeFormat::utcNow()]);
$this->dba->lock('locks');
$lock = $this->dba->selectFirst('locks', ['locked', 'pid'], ['`name` = ? AND `expires` >= ?', $key, DateTimeFormat::utcNow()]);
if (DBA::isResult($lock)) {
if ($this->dba->isResult($lock)) {
if ($lock['locked']) {
// We want to lock something that was already locked by us? So we got the lock.
if ($lock['pid'] == $this->pid) {
@ -46,16 +52,16 @@ class DatabaseLockDriver extends AbstractLockDriver
}
}
if (!$lock['locked']) {
DBA::update('locks', ['locked' => true, 'pid' => $this->pid, 'expires' => DateTimeFormat::utc('now + ' . $ttl . 'seconds')], ['name' => $key]);
$this->dba->update('locks', ['locked' => true, 'pid' => $this->pid, 'expires' => DateTimeFormat::utc('now + ' . $ttl . 'seconds')], ['name' => $key]);
$got_lock = true;
}
} else {
DBA::insert('locks', ['name' => $key, 'locked' => true, 'pid' => $this->pid, 'expires' => DateTimeFormat::utc('now + ' . $ttl . 'seconds')]);
$this->dba->insert('locks', ['name' => $key, 'locked' => true, 'pid' => $this->pid, 'expires' => DateTimeFormat::utc('now + ' . $ttl . 'seconds')]);
$got_lock = true;
$this->markAcquire($key);
}
DBA::unlock();
$this->dba->unlock();
if (!$got_lock && ($timeout > 0)) {
usleep(rand(100000, 2000000));
@ -76,7 +82,7 @@ class DatabaseLockDriver extends AbstractLockDriver
$where = ['name' => $key, 'pid' => $this->pid];
}
$return = DBA::delete('locks', $where);
$return = $this->dba->delete('locks', $where);
$this->markRelease($key);
@ -88,7 +94,7 @@ class DatabaseLockDriver extends AbstractLockDriver
*/
public function releaseAll()
{
$return = DBA::delete('locks', ['pid' => $this->pid]);
$return = $this->dba->delete('locks', ['pid' => $this->pid]);
$this->acquiredLocks = [];
@ -100,9 +106,9 @@ class DatabaseLockDriver extends AbstractLockDriver
*/
public function isLocked($key)
{
$lock = DBA::selectFirst('locks', ['locked'], ['`name` = ? AND `expires` >= ?', $key, DateTimeFormat::utcNow()]);
$lock = $this->dba->selectFirst('locks', ['locked'], ['`name` = ? AND `expires` >= ?', $key, DateTimeFormat::utcNow()]);
if (DBA::isResult($lock)) {
if ($this->dba->isResult($lock)) {
return $lock['locked'] !== false;
} else {
return false;

12
src/Core/Lock/ILockDriver.php

@ -1,6 +1,7 @@
<?php
namespace Friendica\Core\Lock;
use Friendica\Core\Cache;
/**
@ -13,7 +14,8 @@ interface ILockDriver
/**
* Checks, if a key is currently locked to a or my process
*
* @param string $key The name of the lock
* @param string $key The name of the lock
*
* @return bool
*/
public function isLocked($key);
@ -22,13 +24,13 @@ interface ILockDriver
*
* Acquires a lock for a given name
*
* @param string $key The Name of the lock
* @param integer $timeout Seconds until we give up
* @param integer $ttl Seconds The lock lifespan, must be one of the Cache constants
* @param string $key The Name of the lock
* @param integer $timeout Seconds until we give up
* @param integer $ttl Seconds The lock lifespan, must be one of the Cache constants
*
* @return boolean Was the lock successful?
*/
public function acquireLock($key, $timeout = 120, $ttl = Cache::FIVE_MINUTES);
public function acquireLock($key, $timeout = 120, $ttl = Cache\ICacheDriver::FIVE_MINUTES);
/**
* Releases a lock if it was set by us

82
src/Factory/CacheDriverFactory.php

@ -4,7 +4,11 @@ namespace Friendica\Factory;
use Friendica\Core\Cache;
use Friendica\Core\Cache\ICacheDriver;
use Friendica\Core\Config;
use Friendica\Core\Config\Configuration;
use Friendica\Database\Database;
use Friendica\Util\BaseURL;
use Friendica\Util\Profiler;
use Psr\Log\LoggerInterface;
/**
* Class CacheDriverFactory
@ -15,43 +19,79 @@ use Friendica\Core\Config;
*/
class CacheDriverFactory
{
/**
* @var string The default driver for caching
*/
const DEFAULT_DRIVER = 'database';
/**
* @var Configuration The configuration to read parameters out of the config
*/
private $config;
/**
* @var Database The database connection in case that the cache is used the dba connection
*/
private $dba;
/**
* @var string The hostname, used as Prefix for Caching
*/
private $hostname;
/**
* @var Profiler The optional profiler if the cached should be profiled
*/
private $profiler;
/**
* @var LoggerInterface The Friendica Logger
*/
private $logger;
public function __construct(BaseURL $baseURL, Configuration $config, Database $dba, Profiler $profiler, LoggerInterface $logger)
{
$this->hostname = $baseURL->getHostname();
$this->config = $config;
$this->dba = $dba;
$this->profiler = $profiler;
$this->logger = $logger;
}
/**
* This method creates a CacheDriver for the given cache driver name
*
* @param string $driver The name of the cache driver
* @return ICacheDriver The instance of the CacheDriver
* @throws \Exception The exception if something went wrong during the CacheDriver creation
*/
public static function create($driver) {
public function create()
{
$driver = $this->config->get('system', 'cache_driver', self::DEFAULT_DRIVER);
switch ($driver) {
case 'memcache':
$memcache_host = Config::get('system', 'memcache_host');
$memcache_port = Config::get('system', 'memcache_port');
return new Cache\MemcacheCacheDriver($memcache_host, $memcache_port);
$cache = new Cache\MemcacheCacheDriver($this->hostname, $this->config);
break;
case 'memcached':
$memcached_hosts = Config::get('system', 'memcached_hosts');
return new Cache\MemcachedCacheDriver($memcached_hosts);
$cache = new Cache\MemcachedCacheDriver($this->hostname, $this->config, $this->logger);
break;
case 'redis':
$redis_host = Config::get('system', 'redis_host');
$redis_port = Config::get('system', 'redis_port');
$redis_pw = Config::get('system', 'redis_password');
$redis_db = Config::get('system', 'redis_db', 0);
return new Cache\RedisCacheDriver($redis_host, $redis_port, $redis_db, $redis_pw);
$cache = new Cache\RedisCacheDriver($this->hostname, $this->config);
break;
case 'apcu':
return new Cache\APCuCache();
$cache = new Cache\APCuCache($this->hostname);
break;
default:
return new Cache\DatabaseCacheDriver();
$cache = new Cache\DatabaseCacheDriver($this->hostname, $this->dba);
}
$profiling = $this->config->get('system', 'profiling', false);
// In case profiling is enabled, wrap the ProfilerCache around the current cache
if (isset($profiling) && $profiling !== false) {
return new Cache\ProfilerCache($cache, $this->profiler);
} else {
return $cache;
}
}
}

128
src/Factory/LockDriverFactory.php

@ -0,0 +1,128 @@
<?php
namespace Friendica\Factory;
use Friendica\Core\Cache\ICacheDriver;
use Friendica\Core\Cache\IMemoryCacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock;
use Friendica\Database\Database;
use Friendica\Util\Profiler;
use Psr\Log\LoggerInterface;
/**
* Class LockDriverFactory
*
* @package Friendica\Core\Cache
*
* A basic class to generate a LockDriver
*/
class LockDriverFactory
{
/**
* @var string The default driver for caching
*/
const DEFAULT_DRIVER = 'default';
/**
* @var Configuration The configuration to read parameters out of the config
*/
private $config;
/**
* @var Database The database connection in case that the cache is used the dba connection
*/
private $dba;
/**
* @var ICacheDriver The memory cache driver in case we use it
*/
private $cacheDriver;
/**
* @var Profiler The optional profiler if the cached should be profiled
*/
private $profiler;
/**
* @var LoggerInterface The Friendica Logger
*/
private $logger;
public function __construct(ICacheDriver $cacheDriver, Configuration $config, Database $dba, Profiler $profiler, LoggerInterface $logger)
{
$this->cacheDriver = $cacheDriver;
$this->config = $config;
$this->dba = $dba;
$this->logger = $logger;
}
public function create()
{
$lock_driver = $this->config->get('system', 'lock_driver', self::DEFAULT_DRIVER);
try {
switch ($lock_driver) {
case 'memcache':
case 'memcached':
case 'redis':
if ($this->cacheDriver instanceof IMemoryCacheDriver) {
return new Lock\CacheLockDriver($this->cacheDriver);
}
break;
case 'database':
return new Lock\DatabaseLockDriver($this->dba);
break;
case 'semaphore':
return new Lock\SemaphoreLockDriver();
break;
default:
return self::useAutoDriver();
}
} catch (\Exception $exception) {
$this->logger->alert('Driver \'' . $lock_driver . '\' failed - Fallback to \'useAutoDriver()\'', ['exception' => $exception]);
return 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
*
* @return Lock\ILockDriver
*/
private function useAutoDriver()
{
// 1. Try to use Semaphores for - local - locking
if (function_exists('sem_get')) {
try {
return new Lock\SemaphoreLockDriver();
} catch (\Exception $exception) {
$this->logger->debug('Using Semaphore driver for locking failed.', ['exception' => $exception]);
}
}
// 2. Try to use Cache Locking (don't use the DB-Cache Locking because it works different!)
$cache_driver = $this->config->get('system', 'cache_driver', 'database');
if ($cache_driver != 'database') {
try {
if ($this->cacheDriver instanceof IMemoryCacheDriver) {
return new Lock\CacheLockDriver($this->cacheDriver);
}
} catch (\Exception $exception) {
$this->logger->debug('Using Cache driver for locking failed.', ['exception' => $exception]);
}
}
// 3. Use Database Locking as a Fallback
return new Lock\DatabaseLockDriver($this->dba);
}
}

17
static/dependencies.config.php

@ -2,7 +2,9 @@
use Dice\Dice;
use Friendica\App;
use Friendica\Core\Cache;
use Friendica\Core\Config;
use Friendica\Core\Lock\ILockDriver;
use Friendica\Database\Database;
use Friendica\Factory;
use Friendica\Util;
@ -116,4 +118,19 @@ return [
['createDev', [], Dice::CHAIN_CALL],
]
],
Cache\ICacheDriver::class => [
'instanceOf' => Factory\CacheDriverFactory::class,
'call' => [
['create', [], Dice::CHAIN_CALL],
],
],
Cache\IMemoryCacheDriver::class => [
'instanceOf' => Cache\ICacheDriver::class,
],
ILockDriver::class => [
'instanceOf' => Factory\LockDriverFactory::class,
'call' => [
['create', [], Dice::CHAIN_CALL],
],
],
];

48
tests/DatabaseTest.php

@ -5,56 +5,10 @@
namespace Friendica\Test;
use Friendica\Database\Database;
use Friendica\Test\Util\Database\StaticDatabase;
/**
* Abstract class used by tests that need a database.
*/
abstract class DatabaseTest extends MockedTest
{
protected function setUp()
{
parent::setUp();
StaticDatabase::statConnect($_SERVER);
// Rollbacks every DB usage (in case the test couldn't call tearDown)
StaticDatabase::statRollback();
// Start the first, outer transaction
StaticDatabase::getGlobConnection()->beginTransaction();
}
protected function tearDown()
{
// Rollbacks every DB usage so we don't commit anything into the DB
StaticDatabase::statRollback();
parent::tearDown();
}
/**