Refactor Cache/Lock to DICE

- Refactor Cache classes
- Refactor Lock classes
- Improved test speed (removed some seperate class annotations)
This commit is contained in:
Philipp Holzer 2019-08-03 20:48:56 +02:00
parent b95d4f41b9
commit d56bd28a07
No known key found for this signature in database
GPG key ID: D8365C3D36B77D90
40 changed files with 766 additions and 621 deletions

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -2,8 +2,6 @@
namespace Friendica\Core\Cache; namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
/** /**
* Cache Driver Interface * Cache Driver Interface
* *
@ -11,6 +9,16 @@ use Friendica\Core\Cache;
*/ */
interface ICacheDriver 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 * Lists all cache keys
* *
@ -38,7 +46,7 @@ interface ICacheDriver
* *
* @return bool * @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 * Delete a key from the cache

View file

@ -1,7 +1,6 @@
<?php <?php
namespace Friendica\Core\Cache; namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
/** /**
* This interface defines methods for Memory-Caches only * 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 * @param int $ttl The cache lifespan, must be one of the Cache constants
* @return bool * @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 * Compares if the old value is set and sets the new value
@ -32,7 +31,7 @@ interface IMemoryCacheDriver extends ICacheDriver
* *
* @return bool * @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 * Compares if the old value is set and removes it

View file

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

View file

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

View file

@ -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;
}
}
}

View file

@ -4,6 +4,7 @@ namespace Friendica\Core\Cache;
use Exception; use Exception;
use Friendica\Core\Cache; use Friendica\Core\Cache;
use Friendica\Core\Config\Configuration;
use Redis; use Redis;
/** /**
@ -20,20 +21,23 @@ class RedisCacheDriver extends AbstractCacheDriver implements IMemoryCacheDriver
private $redis; 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 * @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)) { if (!class_exists('Redis', false)) {
throw new Exception('Redis class isn\'t available'); throw new Exception('Redis class isn\'t available');
} }
parent::__construct($hostname);
$this->redis = new Redis(); $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)) { if (!$this->redis->connect($redis_host, $redis_port)) {
throw new Exception('Expected Redis server at ' . $redis_host . ':' . $redis_port . ' isn\'t available'); throw new Exception('Expected Redis server at ' . $redis_host . ':' . $redis_port . ' isn\'t available');
} }

View file

@ -7,116 +7,28 @@
namespace Friendica\Core; namespace Friendica\Core;
use Friendica\Factory\CacheDriverFactory; use Friendica\BaseObject;
use Friendica\Core\Cache\IMemoryCacheDriver; 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 * @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 $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? * @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 string $key Name of the lock
* @param bool $override Overrides the lock to get releases * @param bool $override Overrides the lock to get releases
*
* @return void * @return void
* @throws \Exception
*/ */
public static function release($key, $override = false) 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 * @brief Releases all lock that were set by us
* @return void * @return void
* @throws \Exception
*/ */
public static function releaseAll() public static function releaseAll()
{ {
self::getDriver()->releaseAll(); self::getClass(ILockDriver::class)->releaseAll();
} }
} }

View file

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

View file

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

View file

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

View file

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

View file

@ -4,7 +4,11 @@ namespace Friendica\Factory;
use Friendica\Core\Cache; use Friendica\Core\Cache;
use Friendica\Core\Cache\ICacheDriver; 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 * Class CacheDriverFactory
@ -15,43 +19,79 @@ use Friendica\Core\Config;
*/ */
class CacheDriverFactory 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 * 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 * @return ICacheDriver The instance of the CacheDriver
* @throws \Exception The exception if something went wrong during the CacheDriver creation * @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) { switch ($driver) {
case 'memcache': case 'memcache':
$memcache_host = Config::get('system', 'memcache_host'); $cache = new Cache\MemcacheCacheDriver($this->hostname, $this->config);
$memcache_port = Config::get('system', 'memcache_port');
return new Cache\MemcacheCacheDriver($memcache_host, $memcache_port);
break; break;
case 'memcached': case 'memcached':
$memcached_hosts = Config::get('system', 'memcached_hosts'); $cache = new Cache\MemcachedCacheDriver($this->hostname, $this->config, $this->logger);
return new Cache\MemcachedCacheDriver($memcached_hosts);
break; break;
case 'redis': case 'redis':
$redis_host = Config::get('system', 'redis_host'); $cache = new Cache\RedisCacheDriver($this->hostname, $this->config);
$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);
break; break;
case 'apcu': case 'apcu':
return new Cache\APCuCache(); $cache = new Cache\APCuCache($this->hostname);
break; break;
default: 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;
} }
} }
} }

View file

@ -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);
}
}

View file

@ -2,7 +2,9 @@
use Dice\Dice; use Dice\Dice;
use Friendica\App; use Friendica\App;
use Friendica\Core\Cache;
use Friendica\Core\Config; use Friendica\Core\Config;
use Friendica\Core\Lock\ILockDriver;
use Friendica\Database\Database; use Friendica\Database\Database;
use Friendica\Factory; use Friendica\Factory;
use Friendica\Util; use Friendica\Util;
@ -116,4 +118,19 @@ return [
['createDev', [], Dice::CHAIN_CALL], ['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],
],
],
]; ];

View file

@ -5,56 +5,10 @@
namespace Friendica\Test; namespace Friendica\Test;
use Friendica\Database\Database;
use Friendica\Test\Util\Database\StaticDatabase;
/** /**
* Abstract class used by tests that need a database. * Abstract class used by tests that need a database.
*/ */
abstract class DatabaseTest extends MockedTest abstract class DatabaseTest extends MockedTest
{ {
protected function setUp() use DatabaseTestTrait;
{
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();
}
/**
* Loads a given DB fixture for this DB test
*
* @param string $fixture The path to the fixture
* @param Database $dba The DB connection
*
* @throws \Exception
*/
protected function loadFixture(string $fixture, Database $dba)
{
$this->assertFileExists($fixture);
$data = include $fixture;
foreach ($data as $tableName => $rows) {
if (!is_array($rows)) {
$dba->p('TRUNCATE TABLE `' . $tableName . '``');
continue;
}
foreach ($rows as $row) {
$dba->insert($tableName, $row);
}
}
}
} }

View file

@ -0,0 +1,58 @@
<?php
/**
* DatabaseTest class.
*/
namespace Friendica\Test;
use Friendica\Database\Database;
use Friendica\Test\Util\Database\StaticDatabase;
/**
* Abstract class used by tests that need a database.
*/
trait DatabaseTestTrait
{
protected function 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();
parent::setUp();
}
protected function tearDown()
{
// Rollbacks every DB usage so we don't commit anything into the DB
StaticDatabase::statRollback();
parent::tearDown();
}
/**
* Loads a given DB fixture for this DB test
*
* @param string $fixture The path to the fixture
* @param Database $dba The DB connection
*
* @throws \Exception
*/
protected function loadFixture(string $fixture, Database $dba)
{
$data = include $fixture;
foreach ($data as $tableName => $rows) {
if (!is_array($rows)) {
$dba->p('TRUNCATE TABLE `' . $tableName . '``');
continue;
}
foreach ($rows as $row) {
$dba->insert($tableName, $row);
}
}
}
}

View file

@ -4,8 +4,14 @@ namespace Friendica\Test\Util;
trait DbaCacheMockTrait trait DbaCacheMockTrait
{ {
use DBAMockTrait; /**
use DateTimeFormatMockTrait; * @var
*/
protected $dba;
public function __construct()
{
}
protected function mockDelete($key, $return = true, $times = null) protected function mockDelete($key, $return = true, $times = null)
{ {

View file

@ -28,6 +28,7 @@ trait VFSTrait
// create a virtual directory and copy all needed files and folders to it // create a virtual directory and copy all needed files and folders to it
$this->root = vfsStream::setup('friendica', 0777, $structure); $this->root = vfsStream::setup('friendica', 0777, $structure);
$this->setConfigFile('dbstructure.config.php', true);
$this->setConfigFile('defaults.config.php', true); $this->setConfigFile('defaults.config.php', true);
$this->setConfigFile('settings.config.php', true); $this->setConfigFile('settings.config.php', true);
$this->setConfigFile('local.config.php'); $this->setConfigFile('local.config.php');

View file

@ -17,7 +17,7 @@ class APCuCacheDriverTest extends MemoryCacheTest
protected function getInstance() protected function getInstance()
{ {
$this->cache = new APCuCache(); $this->cache = new APCuCache('localhost');
return $this->cache; return $this->cache;
} }

View file

@ -8,7 +8,7 @@ class ArrayCacheDriverTest extends MemoryCacheTest
{ {
protected function getInstance() protected function getInstance()
{ {
$this->cache = new ArrayCache(); $this->cache = new ArrayCache('localhost');
return $this->cache; return $this->cache;
} }

View file

@ -4,15 +4,10 @@ namespace Friendica\Test\src\Core\Cache;
use Friendica\Core\Cache\MemcachedCacheDriver; use Friendica\Core\Cache\MemcachedCacheDriver;
use Friendica\Test\MockedTest; use Friendica\Test\MockedTest;
use Friendica\Test\Util\AppMockTrait;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\PidFile; use Friendica\Util\PidFile;
abstract class CacheTest extends MockedTest abstract class CacheTest extends MockedTest
{ {
use VFSTrait;
use AppMockTrait;
/** /**
* @var int Start time of the mock (used for time operations) * @var int Start time of the mock (used for time operations)
*/ */
@ -30,6 +25,7 @@ abstract class CacheTest extends MockedTest
/** /**
* Dataset for test setting different types in the cache * Dataset for test setting different types in the cache
*
* @return array * @return array
*/ */
public function dataTypesInCache() public function dataTypesInCache()
@ -48,6 +44,7 @@ abstract class CacheTest extends MockedTest
/** /**
* Dataset for simple value sets/gets * Dataset for simple value sets/gets
*
* @return array * @return array
*/ */
public function dataSimple() public function dataSimple()
@ -66,12 +63,6 @@ abstract class CacheTest extends MockedTest
protected function setUp() protected function setUp()
{ {
$this->setUpVfsDir();
$this->mockApp($this->root);
$this->app
->shouldReceive('getHostname')
->andReturn('friendica.local');
parent::setUp(); parent::setUp();
$this->instance = $this->getInstance(); $this->instance = $this->getInstance();
@ -82,10 +73,12 @@ abstract class CacheTest extends MockedTest
/** /**
* @small * @small
* @dataProvider dataSimple * @dataProvider dataSimple
*
* @param mixed $value1 a first * @param mixed $value1 a first
* @param mixed $value2 a second * @param mixed $value2 a second
*/ */
function testSimple($value1, $value2) { function testSimple($value1, $value2)
{
$this->assertNull($this->instance->get('value1')); $this->assertNull($this->instance->get('value1'));
$this->instance->set('value1', $value1); $this->instance->set('value1', $value1);
@ -110,12 +103,14 @@ abstract class CacheTest extends MockedTest
/** /**
* @small * @small
* @dataProvider dataSimple * @dataProvider dataSimple
*
* @param mixed $value1 a first * @param mixed $value1 a first
* @param mixed $value2 a second * @param mixed $value2 a second
* @param mixed $value3 a third * @param mixed $value3 a third
* @param mixed $value4 a fourth * @param mixed $value4 a fourth
*/ */
function testClear($value1, $value2, $value3, $value4) { function testClear($value1, $value2, $value3, $value4)
{
$value = 'ipsum lorum'; $value = 'ipsum lorum';
$this->instance->set('1_value1', $value1); $this->instance->set('1_value1', $value1);
$this->instance->set('1_value2', $value2); $this->instance->set('1_value2', $value2);
@ -166,7 +161,8 @@ abstract class CacheTest extends MockedTest
/** /**
* @medium * @medium
*/ */
function testTTL() { function testTTL()
{
$this->markTestSkipped('taking too much time without mocking'); $this->markTestSkipped('taking too much time without mocking');
$this->assertNull($this->instance->get('value1')); $this->assertNull($this->instance->get('value1'));
@ -183,10 +179,13 @@ abstract class CacheTest extends MockedTest
/** /**
* @small * @small
*
* @param $data mixed the data to store in the cache * @param $data mixed the data to store in the cache
*
* @dataProvider dataTypesInCache * @dataProvider dataTypesInCache
*/ */
function testDifferentTypesInCache($data) { function testDifferentTypesInCache($data)
{
$this->instance->set('val', $data); $this->instance->set('val', $data);
$received = $this->instance->get('val'); $received = $this->instance->get('val');
$this->assertEquals($data, $received, 'Value type changed from ' . gettype($data) . ' to ' . gettype($received)); $this->assertEquals($data, $received, 'Value type changed from ' . gettype($data) . ' to ' . gettype($received));
@ -194,12 +193,15 @@ abstract class CacheTest extends MockedTest
/** /**
* @small * @small
*
* @param mixed $value1 a first * @param mixed $value1 a first
* @param mixed $value2 a second * @param mixed $value2 a second
* @param mixed $value3 a third * @param mixed $value3 a third
*
* @dataProvider dataSimple * @dataProvider dataSimple
*/ */
public function testGetAllKeys($value1, $value2, $value3) { public function testGetAllKeys($value1, $value2, $value3)
{
if ($this->cache instanceof MemcachedCacheDriver) { if ($this->cache instanceof MemcachedCacheDriver) {
$this->markTestSkipped('Memcached doesn\'t support getAllKeys anymore'); $this->markTestSkipped('Memcached doesn\'t support getAllKeys anymore');
} }

View file

@ -3,33 +3,40 @@
namespace Friendica\Test\src\Core\Cache; namespace Friendica\Test\src\Core\Cache;
use Friendica\Core\Cache; use Friendica\Core\Cache;
use Friendica\Factory\CacheDriverFactory; use Friendica\Factory\ConfigFactory;
use Friendica\Test\Util\DbaCacheMockTrait; use Friendica\Test\DatabaseTestTrait;
use Friendica\Test\Util\Database\StaticDatabase;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\ConfigFileLoader;
use Friendica\Util\Profiler;
use Psr\Log\NullLogger;
/**
* @runTestsInSeparateProcesses
* @preserveGlobalState disabled
*/
class DatabaseCacheDriverTest extends CacheTest class DatabaseCacheDriverTest extends CacheTest
{ {
use DbaCacheMockTrait; use DatabaseTestTrait;
use VFSTrait;
public function setUp() protected function setUp()
{ {
$this->mockUtcNow($this->startTime); $this->setUpVfsDir();
$this->mockConnected();
$this->mockConnect();
// The first "clear" at setup
$this->mockClear(false, true, 2);
parent::setUp(); parent::setUp();
} }
protected function getInstance() protected function getInstance()
{ {
$this->cache = CacheDriverFactory::create('database'); $logger = new NullLogger();
$profiler = \Mockery::mock(Profiler::class);
$profiler->shouldReceive('saveTimestamp')->withAnyArgs()->andReturn(true);
// load real config to avoid mocking every config-entry which is related to the Database class
$configFactory = new ConfigFactory();
$loader = new ConfigFileLoader($this->root->url());
$configCache = $configFactory->createCache($loader);
$dba = new StaticDatabase($configCache, $profiler, $logger);
$this->cache = new Cache\DatabaseCacheDriver('database', $dba);
return $this->cache; return $this->cache;
} }
@ -38,104 +45,4 @@ class DatabaseCacheDriverTest extends CacheTest
$this->cache->clear(false); $this->cache->clear(false);
parent::tearDown(); parent::tearDown();
} }
/**
* {@inheritdoc}
* @dataProvider dataSimple
*/
public function testSimple($value1, $value2)
{
// assertNull
$this->mockGet('value1', null, $this->startTime, 1);
// assertEquals
$this->mockSet('value1', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('value1', $value1, $this->startTime, 1);
// assertEquals
$this->mockSet('value1', $value2, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('value1', $value2, $this->startTime, 1);
// assertEquals
$this->mockSet('value2', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('value2', $value1, $this->startTime, 1);
// assertNull
$this->mockGet('not_set', null, $this->startTime, 1);
// assertNull
$this->mockDelete('value1', true, 1);
$this->mockGet('value1', null, $this->startTime, 1);
parent::testSimple($value1, $value2);
}
/**
* {@inheritdoc}
* @dataProvider dataSimple
*/
public function testClear($value1, $value2, $value3, $value4)
{
// assert Equals
$this->mockSet('1_value1', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('1_value2', $value2, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('2_value1', $value3, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('3_value1', $value4, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('1_value1', $value1, $this->startTime, 2);
$this->mockGet('1_value2', $value2, $this->startTime, 2);
$this->mockGet('2_value1', $value3, $this->startTime, 2);
$this->mockGet('3_value1', $value4, $this->startTime, 2);
// assertTrue
$this->mockClear(true, true, 1);
$this->mockClear(false, true, 1);
// assertEquals
$this->mockGet('1_value1', null, $this->startTime, 1);
$this->mockGet('1_value2', null, $this->startTime, 1);
$this->mockGet('2_value3', null, $this->startTime, 1);
$this->mockGet('3_value4', null, $this->startTime, 1);
parent::testClear($value1, $value2, $value3, $value4);
}
/**
* {@inheritdoc}
* @dataProvider dataTypesInCache
*/
public function testDifferentTypesInCache($data)
{
$this->mockSet('val', $data, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('val', $data, $this->startTime, 1);
parent::testDifferentTypesInCache($data);
}
/**
* {@inheritdoc}
* @dataProvider dataSimple
*/
public function testGetAllKeys($value1, $value2, $value3)
{
$this->mockSet('value1', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('value2', $value2,Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('test_value3', $value3, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$result = [
['k' => 'value1'],
['k' => 'value2'],
['k' => 'test_value3'],
];
$this->mockGetAllKeys(null, $result, $this->startTime, 1);
$result = [
['k' => 'test_value3'],
];
$this->mockGetAllKeys('test', $result, $this->startTime, 1);
parent::testGetAllKeys($value1, $value2, $value3);
}
} }

View file

@ -1,9 +1,9 @@
<?php <?php
namespace Friendica\Test\src\Core\Cache; namespace Friendica\Test\src\Core\Cache;
use Friendica\Factory\CacheDriverFactory; use Friendica\Core\Cache\MemcacheCacheDriver;
use Friendica\Core\Config\Configuration;
/** /**
* @requires extension memcache * @requires extension memcache
@ -12,19 +12,19 @@ class MemcacheCacheDriverTest extends MemoryCacheTest
{ {
protected function getInstance() protected function getInstance()
{ {
$this->configMock $configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'memcache_host') ->with('system', 'memcache_host')
->andReturn('localhost'); ->andReturn('localhost');
$configMock
$this->configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'memcache_port') ->with('system', 'memcache_port')
->andReturn(11211); ->andReturn(11211);
$this->cache = CacheDriverFactory::create('memcache'); $this->cache = new MemcacheCacheDriver('localhost', $configMock);
return $this->cache; return $this->cache;
} }
public function tearDown() public function tearDown()

View file

@ -3,7 +3,9 @@
namespace Friendica\Test\src\Core\Cache; namespace Friendica\Test\src\Core\Cache;
use Friendica\Factory\CacheDriverFactory; use Friendica\Core\Cache\MemcachedCacheDriver;
use Friendica\Core\Config\Configuration;
use Psr\Log\NullLogger;
/** /**
* @requires extension memcached * @requires extension memcached
@ -12,12 +14,16 @@ class MemcachedCacheDriverTest extends MemoryCacheTest
{ {
protected function getInstance() protected function getInstance()
{ {
$this->configMock $configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'memcached_hosts') ->with('system', 'memcached_hosts')
->andReturn([0 => 'localhost, 11211']); ->andReturn([0 => 'localhost, 11211']);
$this->cache = CacheDriverFactory::create('memcached'); $logger = new NullLogger();
$this->cache = new MemcachedCacheDriver('localhost', $configMock, $logger);
return $this->cache; return $this->cache;
} }

View file

@ -3,8 +3,6 @@
namespace Friendica\Test\src\Core\Cache; namespace Friendica\Test\src\Core\Cache;
use Friendica\Core\Cache\IMemoryCacheDriver; use Friendica\Core\Cache\IMemoryCacheDriver;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
abstract class MemoryCacheTest extends CacheTest abstract class MemoryCacheTest extends CacheTest
{ {
@ -17,11 +15,6 @@ abstract class MemoryCacheTest extends CacheTest
{ {
parent::setUp(); parent::setUp();
$logger = new NullLogger();
$this->dice->shouldReceive('create')
->with(LoggerInterface::class)
->andReturn($logger);
if (!($this->instance instanceof IMemoryCacheDriver)) { if (!($this->instance instanceof IMemoryCacheDriver)) {
throw new \Exception('MemoryCacheTest unsupported'); throw new \Exception('MemoryCacheTest unsupported');
} }
@ -31,7 +24,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small * @small
* @dataProvider dataSimple * @dataProvider dataSimple
*/ */
function testCompareSet($value1, $value2) { function testCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1')); $this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1); $this->instance->add('value1', $value1);
@ -47,7 +41,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small * @small
* @dataProvider dataSimple * @dataProvider dataSimple
*/ */
function testNegativeCompareSet($value1, $value2) { function testNegativeCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1')); $this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1); $this->instance->add('value1', $value1);
@ -64,7 +59,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small * @small
* @dataProvider dataSimple * @dataProvider dataSimple
*/ */
function testCompareDelete($data) { function testCompareDelete($data)
{
$this->assertNull($this->instance->get('value1')); $this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data); $this->instance->add('value1', $data);
@ -78,7 +74,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small * @small
* @dataProvider dataSimple * @dataProvider dataSimple
*/ */
function testNegativeCompareDelete($data) { function testNegativeCompareDelete($data)
{
$this->assertNull($this->instance->get('value1')); $this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data); $this->instance->add('value1', $data);
@ -95,7 +92,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small * @small
* @dataProvider dataSimple * @dataProvider dataSimple
*/ */
function testAdd($value1, $value2) { function testAdd($value1, $value2)
{
$this->assertNull($this->instance->get('value1')); $this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1); $this->instance->add('value1', $value1);
@ -111,4 +109,4 @@ abstract class MemoryCacheTest extends CacheTest
$this->assertEquals($value2, $received, 'Value was not overwritten by add'); $this->assertEquals($value2, $received, 'Value was not overwritten by add');
$this->assertNotEquals($value1, $received, 'Value was not overwritten by any other value'); $this->assertNotEquals($value1, $received, 'Value was not overwritten by any other value');
} }
} }

View file

@ -3,7 +3,8 @@
namespace Friendica\Test\src\Core\Cache; namespace Friendica\Test\src\Core\Cache;
use Friendica\Factory\CacheDriverFactory; use Friendica\Core\Cache\RedisCacheDriver;
use Friendica\Core\Config\Configuration;
/** /**
* @requires extension redis * @requires extension redis
@ -12,27 +13,27 @@ class RedisCacheDriverTest extends MemoryCacheTest
{ {
protected function getInstance() protected function getInstance()
{ {
$this->configMock $configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_host') ->with('system', 'redis_host')
->andReturn('localhost'); ->andReturn('localhost');
$configMock
$this->configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_port') ->with('system', 'redis_port')
->andReturn(null); ->andReturn(null);
$this->configMock $configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_db') ->with('system', 'redis_db', 0)
->andReturn(3); ->andReturn(3);
$configMock
$this->configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_password') ->with('system', 'redis_password')
->andReturn(null); ->andReturn(null);
$this->cache = CacheDriverFactory::create('redis'); $this->cache = new RedisCacheDriver('localhost', $configMock);
return $this->cache; return $this->cache;
} }

View file

@ -2,7 +2,6 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache\APCuCache; use Friendica\Core\Cache\APCuCache;
use Friendica\Core\Lock\CacheLockDriver; use Friendica\Core\Lock\CacheLockDriver;
@ -19,6 +18,6 @@ class APCuCacheLockDriverTest extends LockTest
protected function getInstance() protected function getInstance()
{ {
return new CacheLockDriver(new APCuCache()); return new CacheLockDriver(new APCuCache('localhost'));
} }
} }

View file

@ -2,7 +2,6 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache\ArrayCache; use Friendica\Core\Cache\ArrayCache;
use Friendica\Core\Lock\CacheLockDriver; use Friendica\Core\Lock\CacheLockDriver;
@ -10,7 +9,7 @@ class ArrayCacheLockDriverTest extends LockTest
{ {
protected function getInstance() protected function getInstance()
{ {
return new CacheLockDriver(new ArrayCache()); return new CacheLockDriver(new ArrayCache('localhost'));
} }
public function testLockTTL() public function testLockTTL()

View file

@ -2,117 +2,42 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache;
use Friendica\Core\Lock\DatabaseLockDriver; use Friendica\Core\Lock\DatabaseLockDriver;
use Friendica\Test\Util\DbaLockMockTrait; use Friendica\Factory\ConfigFactory;
use Friendica\Test\DatabaseTestTrait;
use Friendica\Test\Util\Database\StaticDatabase;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\ConfigFileLoader;
use Friendica\Util\Profiler;
use Psr\Log\NullLogger;
/**
* @runTestsInSeparateProcesses
* @preserveGlobalState disabled
*/
class DatabaseLockDriverTest extends LockTest class DatabaseLockDriverTest extends LockTest
{ {
use DbaLockMockTrait; use VFSTrait;
use DatabaseTestTrait;
protected $pid = 123; protected $pid = 123;
protected function setUp() protected function setUp()
{ {
$this->mockConnected(); $this->setUpVfsDir();
$this->mockConnect();
$this->mockReleaseAll($this->pid, 2);
parent::setUp(); parent::setUp();
} }
protected function getInstance() protected function getInstance()
{ {
return new DatabaseLockDriver($this->pid); $logger = new NullLogger();
} $profiler = \Mockery::mock(Profiler::class);
$profiler->shouldReceive('saveTimestamp')->withAnyArgs()->andReturn(true);
public function testLock() // load real config to avoid mocking every config-entry which is related to the Database class
{ $configFactory = new ConfigFactory();
$this->mockIsLocked('foo', false, $this->startTime, 1); $loader = new ConfigFileLoader($this->root->url());
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1); $configCache = $configFactory->createCache($loader);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
parent::testLock(); $dba = new StaticDatabase($configCache, $profiler, $logger);
}
public function testDoubleLock() return new DatabaseLockDriver($dba, $this->pid);
{
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, true, $this->pid, true, $this->startTime, 1);
parent::testDoubleLock();
}
public function testReleaseLock()
{
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockReleaseLock('foo', $this->pid, 1);
$this->mockIsLocked('foo', false, $this->startTime, 1);
parent::testReleaseLock();
}
public function testReleaseAll()
{
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('bar', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('nice', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockIsLocked('bar', true, $this->startTime, 1);
$this->mockIsLocked('nice', true, $this->startTime, 1);
$this->mockReleaseAll($this->pid, 1);
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
$this->mockIsLocked('nice', false, $this->startTime, 1);
parent::testReleaseAll();
}
public function testReleaseAfterUnlock()
{
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
$this->mockIsLocked('nice', false, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('bar', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('nice', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockReleaseLock('foo', $this->pid, 1);
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockIsLocked('bar', true, $this->startTime, 1);
$this->mockIsLocked('nice', true, $this->startTime, 1);
$this->mockReleaseAll($this->pid, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
$this->mockIsLocked('nice', false, $this->startTime, 1);
parent::testReleaseAfterUnlock();
}
public function testReleaseWitTTL()
{
$this->mockIsLocked('test', false, $this->startTime, 1);
$this->mockAcquireLock('test', 10, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('test', true, $this->startTime, 1);
$this->mockReleaseLock('test', $this->pid, 1);
$this->mockIsLocked('test', false, $this->startTime, 1);
parent::testReleaseWitTTL();
} }
} }

View file

@ -3,16 +3,9 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Friendica\Test\MockedTest; use Friendica\Test\MockedTest;
use Friendica\Test\Util\AppMockTrait;
use Friendica\Test\Util\VFSTrait;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
abstract class LockTest extends MockedTest abstract class LockTest extends MockedTest
{ {
use VFSTrait;
use AppMockTrait;
/** /**
* @var int Start time of the mock (used for time operations) * @var int Start time of the mock (used for time operations)
*/ */
@ -27,19 +20,8 @@ abstract class LockTest extends MockedTest
protected function setUp() protected function setUp()
{ {
// Reusable App object
$this->setUpVfsDir();
$this->mockApp($this->root);
$this->app
->shouldReceive('getHostname')
->andReturn('friendica.local');
$logger = new NullLogger();
$this->dice->shouldReceive('create')
->with(LoggerInterface::class)
->andReturn($logger);
parent::setUp(); parent::setUp();
$this->instance = $this->getInstance(); $this->instance = $this->getInstance();
$this->instance->releaseAll(); $this->instance->releaseAll();
} }
@ -53,7 +35,8 @@ abstract class LockTest extends MockedTest
/** /**
* @small * @small
*/ */
public function testLock() { public function testLock()
{
$this->assertFalse($this->instance->isLocked('foo')); $this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1)); $this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo')); $this->assertTrue($this->instance->isLocked('foo'));
@ -63,7 +46,8 @@ abstract class LockTest extends MockedTest
/** /**
* @small * @small
*/ */
public function testDoubleLock() { public function testDoubleLock()
{
$this->assertFalse($this->instance->isLocked('foo')); $this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1)); $this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo')); $this->assertTrue($this->instance->isLocked('foo'));
@ -74,7 +58,8 @@ abstract class LockTest extends MockedTest
/** /**
* @small * @small
*/ */
public function testReleaseLock() { public function testReleaseLock()
{
$this->assertFalse($this->instance->isLocked('foo')); $this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1)); $this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo')); $this->assertTrue($this->instance->isLocked('foo'));
@ -85,7 +70,8 @@ abstract class LockTest extends MockedTest
/** /**
* @small * @small
*/ */
public function testReleaseAll() { public function testReleaseAll()
{
$this->assertTrue($this->instance->acquireLock('foo', 1)); $this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->acquireLock('bar', 1)); $this->assertTrue($this->instance->acquireLock('bar', 1));
$this->assertTrue($this->instance->acquireLock('nice', 1)); $this->assertTrue($this->instance->acquireLock('nice', 1));
@ -104,7 +90,8 @@ abstract class LockTest extends MockedTest
/** /**
* @small * @small
*/ */
public function testReleaseAfterUnlock() { public function testReleaseAfterUnlock()
{
$this->assertFalse($this->instance->isLocked('foo')); $this->assertFalse($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar')); $this->assertFalse($this->instance->isLocked('bar'));
$this->assertFalse($this->instance->isLocked('nice')); $this->assertFalse($this->instance->isLocked('nice'));
@ -139,7 +126,8 @@ abstract class LockTest extends MockedTest
/** /**
* @medium * @medium
*/ */
function testLockTTL() { function testLockTTL()
{
$this->markTestSkipped('taking too much time without mocking'); $this->markTestSkipped('taking too much time without mocking');
$this->assertFalse($this->instance->isLocked('foo')); $this->assertFalse($this->instance->isLocked('foo'));

View file

@ -3,7 +3,8 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Friendica\Factory\CacheDriverFactory; use Friendica\Core\Cache\MemcacheCacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\CacheLockDriver; use Friendica\Core\Lock\CacheLockDriver;
/** /**
@ -13,16 +14,17 @@ class MemcacheCacheLockDriverTest extends LockTest
{ {
protected function getInstance() protected function getInstance()
{ {
$this->configMock $configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'memcache_host') ->with('system', 'memcache_host')
->andReturn('localhost'); ->andReturn('localhost');
$configMock
$this->configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'memcache_port') ->with('system', 'memcache_port')
->andReturn(11211); ->andReturn(11211);
return new CacheLockDriver(CacheDriverFactory::create('memcache')); return new CacheLockDriver(new MemcacheCacheDriver('localhost', $configMock));
} }
} }

View file

@ -3,8 +3,10 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Friendica\Factory\CacheDriverFactory; use Friendica\Core\Cache\MemcachedCacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\CacheLockDriver; use Friendica\Core\Lock\CacheLockDriver;
use Psr\Log\NullLogger;
/** /**
* @requires extension memcached * @requires extension memcached
@ -13,11 +15,15 @@ class MemcachedCacheLockDriverTest extends LockTest
{ {
protected function getInstance() protected function getInstance()
{ {
$this->configMock $configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'memcached_hosts') ->with('system', 'memcached_hosts')
->andReturn([0 => 'localhost, 11211']); ->andReturn([0 => 'localhost, 11211']);
return new CacheLockDriver(CacheDriverFactory::create('memcached')); $logger = new NullLogger();
return new CacheLockDriver(new MemcachedCacheDriver('localhost', $configMock, $logger));
} }
} }

View file

@ -3,8 +3,9 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache\RedisCacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\CacheLockDriver; use Friendica\Core\Lock\CacheLockDriver;
use Friendica\Factory\CacheDriverFactory;
/** /**
* @requires extension redis * @requires extension redis
@ -13,26 +14,26 @@ class RedisCacheLockDriverTest extends LockTest
{ {
protected function getInstance() protected function getInstance()
{ {
$this->configMock $configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_host') ->with('system', 'redis_host')
->andReturn('localhost'); ->andReturn('localhost');
$configMock
$this->configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_port') ->with('system', 'redis_port')
->andReturn(null); ->andReturn(null);
$this->configMock $configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_db') ->with('system', 'redis_db', 0)
->andReturn(3); ->andReturn(3);
$configMock
$this->configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'redis_password') ->with('system', 'redis_password')
->andReturn(null); ->andReturn(null);
return new CacheLockDriver(CacheDriverFactory::create('redis')); return new CacheLockDriver(new RedisCacheDriver('localhost', $configMock));
} }
} }

View file

@ -2,6 +2,10 @@
namespace Friendica\Test\src\Core\Lock; namespace Friendica\Test\src\Core\Lock;
use Dice\Dice;
use Friendica\App;
use Friendica\BaseObject;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\SemaphoreLockDriver; use Friendica\Core\Lock\SemaphoreLockDriver;
class SemaphoreLockDriverTest extends LockTest class SemaphoreLockDriverTest extends LockTest
@ -10,12 +14,21 @@ class SemaphoreLockDriverTest extends LockTest
{ {
parent::setUp(); parent::setUp();
$this->app->shouldReceive('getHostname')->andReturn('friendica.local'); $dice = \Mockery::mock(Dice::class)->makePartial();
$this->configMock $app = \Mockery::mock(App::class);
$app->shouldReceive('getHostname')->andReturn('friendica.local');
$dice->shouldReceive('create')->with(App::class)->andReturn($app);
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get') ->shouldReceive('get')
->with('system', 'temppath') ->with('system', 'temppath', NULL, false)
->andReturn('/tmp/'); ->andReturn('/tmp/');
$dice->shouldReceive('create')->with(Configuration::class)->andReturn($configMock);
// @todo Because "get_temppath()" is using static methods, we have to initialize the BaseObject
BaseObject::setDependencyInjection($dice);
} }
protected function getInstance() protected function getInstance()