Browse Source

Refactor Cache/Lock to DICE

- Refactor Cache classes
- Refactor Lock classes
- Improved test speed (removed some seperate class annotations)
tags/2019.09
Philipp Holzer 4 months ago
parent
commit
d56bd28a07
No account linked to committer's email address
40 changed files with 766 additions and 621 deletions
  1. 26
    14
      src/Console/Cache.php
  2. 20
    61
      src/Core/Cache.php
  3. 3
    1
      src/Core/Cache/APCuCache.php
  4. 13
    6
      src/Core/Cache/AbstractCacheDriver.php
  5. 0
    1
      src/Core/Cache/ArrayCache.php
  6. 22
    10
      src/Core/Cache/DatabaseCacheDriver.php
  7. 11
    3
      src/Core/Cache/ICacheDriver.php
  8. 2
    3
      src/Core/Cache/IMemoryCacheDriver.php
  9. 8
    5
      src/Core/Cache/MemcacheCacheDriver.php
  10. 17
    6
      src/Core/Cache/MemcachedCacheDriver.php
  11. 155
    0
      src/Core/Cache/ProfilerCache.php
  12. 9
    5
      src/Core/Cache/RedisCacheDriver.php
  13. 15
    100
      src/Core/Lock.php
  14. 2
    2
      src/Core/Lock/AbstractLockDriver.php
  15. 7
    7
      src/Core/Lock/CacheLockDriver.php
  16. 19
    13
      src/Core/Lock/DatabaseLockDriver.php
  17. 7
    5
      src/Core/Lock/ILockDriver.php
  18. 61
    21
      src/Factory/CacheDriverFactory.php
  19. 128
    0
      src/Factory/LockDriverFactory.php
  20. 17
    0
      static/dependencies.config.php
  21. 1
    47
      tests/DatabaseTest.php
  22. 58
    0
      tests/DatabaseTestTrait.php
  23. 8
    2
      tests/Util/DbaCacheMockTrait.php
  24. 1
    0
      tests/Util/VFSTrait.php
  25. 1
    1
      tests/src/Core/Cache/APCuCacheDriverTest.php
  26. 1
    1
      tests/src/Core/Cache/ArrayCacheDriverTest.php
  27. 18
    16
      tests/src/Core/Cache/CacheTest.php
  28. 23
    116
      tests/src/Core/Cache/DatabaseCacheDriverTest.php
  29. 7
    7
      tests/src/Core/Cache/MemcacheCacheDriverTest.php
  30. 9
    3
      tests/src/Core/Cache/MemcachedCacheDriverTest.php
  31. 11
    13
      tests/src/Core/Cache/MemoryCacheTest.php
  32. 10
    9
      tests/src/Core/Cache/RedisCacheDriverTest.php
  33. 1
    2
      tests/src/Core/Lock/APCuCacheLockDriverTest.php
  34. 1
    2
      tests/src/Core/Lock/ArrayCacheLockDriverTest.php
  35. 19
    94
      tests/src/Core/Lock/DatabaseLockDriverTest.php
  36. 13
    25
      tests/src/Core/Lock/LockTest.php
  37. 7
    5
      tests/src/Core/Lock/MemcacheCacheLockDriverTest.php
  38. 9
    3
      tests/src/Core/Lock/MemcachedCacheLockDriverTest.php
  39. 10
    9
      tests/src/Core/Lock/RedisCacheLockDriverTest.php
  40. 16
    3
      tests/src/Core/Lock/SemaphoreLockDriverTest.php

+ 26
- 14
src/Console/Cache.php View File

@@ -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 {

+ 20
- 61
src/Core/Cache.php View File

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

+ 3
- 1
src/Core/Cache/APCuCache.php View File

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

/**

+ 13
- 6
src/Core/Cache/AbstractCacheDriver.php View File

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

}
}

+ 0
- 1
src/Core/Cache/ArrayCache.php View File

@@ -2,7 +2,6 @@

namespace Friendica\Core\Cache;


use Friendica\Core\Cache;

/**

+ 22
- 10
src/Core/Cache/DatabaseCacheDriver.php View File

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

+ 11
- 3
src/Core/Cache/ICacheDriver.php View File

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

+ 2
- 3
src/Core/Cache/IMemoryCacheDriver.php View File

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

+ 8
- 5
src/Core/Cache/MemcacheCacheDriver.php View File

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

+ 17
- 6
src/Core/Cache/MemcachedCacheDriver.php View File

@@ -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
- 0
src/Core/Cache/ProfilerCache.php 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;
}
}
}

+ 9
- 5
src/Core/Cache/RedisCacheDriver.php View File

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

+ 15
- 100
src/Core/Lock.php View File

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

+ 2
- 2
src/Core/Lock/AbstractLockDriver.php View File

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

+ 7
- 7
src/Core/Lock/CacheLockDriver.php View File

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

+ 19
- 13
src/Core/Lock/DatabaseLockDriver.php View File

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

+ 7
- 5
src/Core/Lock/ILockDriver.php View File

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

+ 61
- 21
src/Factory/CacheDriverFactory.php View File

@@ -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
- 0
src/Factory/LockDriverFactory.php 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);
}
}

+ 17
- 0
static/dependencies.config.php View File

@@ -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],
],
],
];

+ 1
- 47
tests/DatabaseTest.php View File

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

/**
* 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);
}
}
}
use DatabaseTestTrait;
}

+ 58
- 0
tests/DatabaseTestTrait.php 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);
}
}
}
}

+ 8
- 2
tests/Util/DbaCacheMockTrait.php View File

@@ -4,8 +4,14 @@ namespace Friendica\Test\Util;

trait DbaCacheMockTrait
{
use DBAMockTrait;
use DateTimeFormatMockTrait;
/**
* @var
*/
protected $dba;

public function __construct()
{
}

protected function mockDelete($key, $return = true, $times = null)
{

+ 1
- 0
tests/Util/VFSTrait.php View File

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

$this->setConfigFile('dbstructure.config.php', true);
$this->setConfigFile('defaults.config.php', true);
$this->setConfigFile('settings.config.php', true);
$this->setConfigFile('local.config.php');

+ 1
- 1
tests/src/Core/Cache/APCuCacheDriverTest.php View File

@@ -17,7 +17,7 @@ class APCuCacheDriverTest extends MemoryCacheTest

protected function getInstance()
{
$this->cache = new APCuCache();
$this->cache = new APCuCache('localhost');
return $this->cache;
}


+ 1
- 1
tests/src/Core/Cache/ArrayCacheDriverTest.php View File

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


+ 18
- 16
tests/src/Core/Cache/CacheTest.php View File

@@ -4,15 +4,10 @@ namespace Friendica\Test\src\Core\Cache;

use Friendica\Core\Cache\MemcachedCacheDriver;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\AppMockTrait;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\PidFile;

abstract class CacheTest extends MockedTest
{
use VFSTrait;
use AppMockTrait;

/**
* @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
*
* @return array
*/
public function dataTypesInCache()
@@ -48,6 +44,7 @@ abstract class CacheTest extends MockedTest

/**
* Dataset for simple value sets/gets
*
* @return array
*/
public function dataSimple()
@@ -66,12 +63,6 @@ abstract class CacheTest extends MockedTest

protected function setUp()
{
$this->setUpVfsDir();
$this->mockApp($this->root);
$this->app
->shouldReceive('getHostname')
->andReturn('friendica.local');

parent::setUp();

$this->instance = $this->getInstance();
@@ -82,10 +73,12 @@ abstract class CacheTest extends MockedTest
/**
* @small
* @dataProvider dataSimple
*
* @param mixed $value1 a first
* @param mixed $value2 a second
*/
function testSimple($value1, $value2) {
function testSimple($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));

$this->instance->set('value1', $value1);
@@ -110,12 +103,14 @@ abstract class CacheTest extends MockedTest
/**
* @small
* @dataProvider dataSimple
*
* @param mixed $value1 a first
* @param mixed $value2 a second
* @param mixed $value3 a third
* @param mixed $value4 a fourth
*/
function testClear($value1, $value2, $value3, $value4) {
function testClear($value1, $value2, $value3, $value4)
{
$value = 'ipsum lorum';
$this->instance->set('1_value1', $value1);
$this->instance->set('1_value2', $value2);
@@ -166,7 +161,8 @@ abstract class CacheTest extends MockedTest
/**
* @medium
*/
function testTTL() {
function testTTL()
{
$this->markTestSkipped('taking too much time without mocking');

$this->assertNull($this->instance->get('value1'));
@@ -183,10 +179,13 @@ abstract class CacheTest extends MockedTest

/**
* @small
*
* @param $data mixed the data to store in the cache
*
* @dataProvider dataTypesInCache
*/
function testDifferentTypesInCache($data) {
function testDifferentTypesInCache($data)
{
$this->instance->set('val', $data);
$received = $this->instance->get('val');
$this->assertEquals($data, $received, 'Value type changed from ' . gettype($data) . ' to ' . gettype($received));
@@ -194,12 +193,15 @@ abstract class CacheTest extends MockedTest

/**
* @small
*
* @param mixed $value1 a first
* @param mixed $value2 a second
* @param mixed $value3 a third
*
* @dataProvider dataSimple
*/
public function testGetAllKeys($value1, $value2, $value3) {
public function testGetAllKeys($value1, $value2, $value3)
{
if ($this->cache instanceof MemcachedCacheDriver) {
$this->markTestSkipped('Memcached doesn\'t support getAllKeys anymore');
}

+ 23
- 116
tests/src/Core/Cache/DatabaseCacheDriverTest.php View File

@@ -3,33 +3,40 @@
namespace Friendica\Test\src\Core\Cache;

use Friendica\Core\Cache;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Test\Util\DbaCacheMockTrait;
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 DatabaseCacheDriverTest extends CacheTest
{
use DbaCacheMockTrait;
use DatabaseTestTrait;
use VFSTrait;

public function setUp()
protected function setUp()
{
$this->mockUtcNow($this->startTime);

$this->mockConnected();
$this->mockConnect();

// The first "clear" at setup
$this->mockClear(false, true, 2);
$this->setUpVfsDir();

parent::setUp();
}

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

@@ -38,104 +45,4 @@ class DatabaseCacheDriverTest extends CacheTest
$this->cache->clear(false);
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);
}
}

+ 7
- 7
tests/src/Core/Cache/MemcacheCacheDriverTest.php View File

@@ -1,9 +1,9 @@
<?php


namespace Friendica\Test\src\Core\Cache;

use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\MemcacheCacheDriver;
use Friendica\Core\Config\Configuration;

/**
* @requires extension memcache
@@ -12,19 +12,19 @@ class MemcacheCacheDriverTest extends MemoryCacheTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);

$configMock
->shouldReceive('get')
->with('system', 'memcache_host')
->andReturn('localhost');

$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'memcache_port')
->andReturn(11211);

$this->cache = CacheDriverFactory::create('memcache');
$this->cache = new MemcacheCacheDriver('localhost', $configMock);
return $this->cache;

}

public function tearDown()

+ 9
- 3
tests/src/Core/Cache/MemcachedCacheDriverTest.php View File

@@ -3,7 +3,9 @@

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
@@ -12,12 +14,16 @@ class MemcachedCacheDriverTest extends MemoryCacheTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);

$configMock
->shouldReceive('get')
->with('system', 'memcached_hosts')
->andReturn([0 => 'localhost, 11211']);

$this->cache = CacheDriverFactory::create('memcached');
$logger = new NullLogger();

$this->cache = new MemcachedCacheDriver('localhost', $configMock, $logger);
return $this->cache;
}


+ 11
- 13
tests/src/Core/Cache/MemoryCacheTest.php View File

@@ -3,8 +3,6 @@
namespace Friendica\Test\src\Core\Cache;

use Friendica\Core\Cache\IMemoryCacheDriver;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

abstract class MemoryCacheTest extends CacheTest
{
@@ -17,11 +15,6 @@ abstract class MemoryCacheTest extends CacheTest
{
parent::setUp();

$logger = new NullLogger();
$this->dice->shouldReceive('create')
->with(LoggerInterface::class)
->andReturn($logger);

if (!($this->instance instanceof IMemoryCacheDriver)) {
throw new \Exception('MemoryCacheTest unsupported');
}
@@ -31,7 +24,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testCompareSet($value1, $value2) {
function testCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));

$this->instance->add('value1', $value1);
@@ -47,7 +41,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testNegativeCompareSet($value1, $value2) {
function testNegativeCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));

$this->instance->add('value1', $value1);
@@ -64,7 +59,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testCompareDelete($data) {
function testCompareDelete($data)
{
$this->assertNull($this->instance->get('value1'));

$this->instance->add('value1', $data);
@@ -78,7 +74,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testNegativeCompareDelete($data) {
function testNegativeCompareDelete($data)
{
$this->assertNull($this->instance->get('value1'));

$this->instance->add('value1', $data);
@@ -95,7 +92,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testAdd($value1, $value2) {
function testAdd($value1, $value2)
{
$this->assertNull($this->instance->get('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->assertNotEquals($value1, $received, 'Value was not overwritten by any other value');
}
}
}

+ 10
- 9
tests/src/Core/Cache/RedisCacheDriverTest.php View File

@@ -3,7 +3,8 @@

namespace Friendica\Test\src\Core\Cache;

use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\RedisCacheDriver;
use Friendica\Core\Config\Configuration;

/**
* @requires extension redis
@@ -12,27 +13,27 @@ class RedisCacheDriverTest extends MemoryCacheTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);

$configMock
->shouldReceive('get')
->with('system', 'redis_host')
->andReturn('localhost');

$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_port')
->andReturn(null);

$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_db')
->with('system', 'redis_db', 0)
->andReturn(3);

$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_password')
->andReturn(null);

$this->cache = CacheDriverFactory::create('redis');
$this->cache = new RedisCacheDriver('localhost', $configMock);
return $this->cache;
}


+ 1
- 2
tests/src/Core/Lock/APCuCacheLockDriverTest.php View File

@@ -2,7 +2,6 @@

namespace Friendica\Test\src\Core\Lock;


use Friendica\Core\Cache\APCuCache;
use Friendica\Core\Lock\CacheLockDriver;

@@ -19,6 +18,6 @@ class APCuCacheLockDriverTest extends LockTest

protected function getInstance()
{
return new CacheLockDriver(new APCuCache());
return new CacheLockDriver(new APCuCache('localhost'));
}
}

+ 1
- 2
tests/src/Core/Lock/ArrayCacheLockDriverTest.php View File

@@ -2,7 +2,6 @@

namespace Friendica\Test\src\Core\Lock;


use Friendica\Core\Cache\ArrayCache;
use Friendica\Core\Lock\CacheLockDriver;