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;
/**
*/
private $appMode;
+ /**
+ * @var string The cache driver name
+ */
+ private $cacheDriverName;
+
+ /**
+ * @var ICacheDriver
+ */
+ private $cache;
+
protected function getHelp()
{
$help = <<<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()
$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)) {
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:');
{
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 {
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}");
}
private function executeFlush()
{
- $result = Core\Cache::clear();
+ $result = $this->cache->clear();
if ($result) {
$this->out('Cache successfully flushed');
} else {
private function executeClear()
{
- $result = Core\Cache::clear(false);
+ $result = $this->cache->clear(false);
if ($result) {
$this->out('Cache successfully cleared');
} else {
*/
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
*
*/
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);
}
/**
*/
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);
}
/**
* @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);
}
/**
*/
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);
}
/**
* @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);
}
}
/**
* @throws Exception
*/
- public function __construct()
+ public function __construct(string $hostname)
{
if (!self::isAvailable()) {
throw new Exception('APCu is not available.');
}
+
+ parent::__construct($hostname);
}
/**
<?php
namespace Friendica\Core\Cache;
-use Friendica\BaseObject;
-
/**
* Abstract class for common used functions
*
* @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)
*
protected function getPrefix()
{
// We fetch with the hostname as key to avoid problems with other applications
- return self::getApp()->getHostName();
+ return $this->hostName;
}
/**
} 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);
return $result;
}
-
}
}
namespace Friendica\Core\Cache;
-
use Friendica\Core\Cache;
/**
namespace Friendica\Core\Cache;
use Friendica\Core\Cache;
-use Friendica\Database\DBA;
+use Friendica\Database\Database;
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)
*/
$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;
}
*/
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);
];
}
- return DBA::update('cache', $fields, ['k' => $key], true);
+ return $this->dba->update('cache', $fields, ['k' => $key], true);
}
/**
*/
public function delete($key)
{
- return DBA::delete('cache', ['k' => $key]);
+ return $this->dba->delete('cache', ['k' => $key]);
}
/**
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 ']);
}
}
}
namespace Friendica\Core\Cache;
-use Friendica\Core\Cache;
-
/**
* Cache Driver Interface
*
*/
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
*
*
* @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
<?php
namespace Friendica\Core\Cache;
-use Friendica\Core\Cache;
/**
* This interface defines methods for Memory-Caches only
* @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
*
* @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
namespace Friendica\Core\Cache;
-use Friendica\Core\Cache;
-
use Exception;
+use Friendica\Core\Cache;
+use Friendica\Core\Config\Configuration;
use Memcache;
/**
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');
}
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
*/
private $memcached;
+ /**
+ * @var LoggerInterface
+ */
+ private $logger;
+
/**
* Due to limitations of the INI format, the expected configuration for Memcached servers is the following:
* array {
* @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));
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 [];
}
}
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;
--- /dev/null
+<?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;
+ }
+ }
+}
use Exception;
use Friendica\Core\Cache;
+use Friendica\Core\Config\Configuration;
use 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
*/
- 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');
}
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);
}
/**
*
* @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();
}
}
<?php
namespace Friendica\Core\Lock;
-use Friendica\BaseObject;
/**
* Class AbstractLockDriver
*
* 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
* 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)
public function acquireLock($key, $timeout = 120, $ttl = Cache::FIVE_MINUTES)
{
$got_lock = false;
- $start = time();
+ $start = time();
$cachekey = self::getLockKey($key);
{
$cachekey = self::getLockKey($key);
- $return = false;
-
if ($override) {
$return = $this->cache->delete($cachekey);
} else {
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;
}
}
namespace Friendica\Core\Lock;
use Friendica\Core\Cache;
-use Friendica\Database\DBA;
+use Friendica\Database\Database;
use Friendica\Util\DateTimeFormat;
/**
*/
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();
}
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) {
}
}
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));
$where = ['name' => $key, 'pid' => $this->pid];
}
- $return = DBA::delete('locks', $where);
+ $return = $this->dba->delete('locks', $where);
$this->markRelease($key);
*/
public function releaseAll()
{
- $return = DBA::delete('locks', ['pid' => $this->pid]);
+ $return = $this->dba->delete('locks', ['pid' => $this->pid]);
$this->acquiredLocks = [];
*/
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;
<?php
namespace Friendica\Core\Lock;
+
use Friendica\Core\Cache;
/**
/**
* 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);
*
* 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
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
*/
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;
}
}
}
--- /dev/null
+<?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);
+ }
+}
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;
['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],
+ ],
+ ],
];
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;
}
--- /dev/null
+<?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);
+ }
+ }
+ }
+}
trait DbaCacheMockTrait
{
- use DBAMockTrait;
- use DateTimeFormatMockTrait;
+ /**
+ * @var
+ */
+ protected $dba;
+
+ public function __construct()
+ {
+ }
protected function mockDelete($key, $return = true, $times = null)
{
// 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');
protected function getInstance()
{
- $this->cache = new APCuCache();
+ $this->cache = new APCuCache('localhost');
return $this->cache;
}
{
protected function getInstance()
{
- $this->cache = new ArrayCache();
+ $this->cache = new ArrayCache('localhost');
return $this->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)
*/
/**
* Dataset for test setting different types in the cache
+ *
* @return array
*/
public function dataTypesInCache()
/**
* Dataset for simple value sets/gets
+ *
* @return array
*/
public function dataSimple()
protected function setUp()
{
- $this->setUpVfsDir();
- $this->mockApp($this->root);
- $this->app
- ->shouldReceive('getHostname')
- ->andReturn('friendica.local');
-
parent::setUp();
$this->instance = $this->getInstance();
/**
* @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);
/**
* @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);
/**
* @medium
*/
- function testTTL() {
+ function testTTL()
+ {
$this->markTestSkipped('taking too much time without mocking');
$this->assertNull($this->instance->get('value1'));
/**
* @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));
/**
* @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');
}
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;
}
$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);
- }
}
<?php
-
namespace Friendica\Test\src\Core\Cache;
-use Friendica\Factory\CacheDriverFactory;
+use Friendica\Core\Cache\MemcacheCacheDriver;
+use Friendica\Core\Config\Configuration;
/**
* @requires extension memcache
{
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()
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
{
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;
}
namespace Friendica\Test\src\Core\Cache;
use Friendica\Core\Cache\IMemoryCacheDriver;
-use Psr\Log\LoggerInterface;
-use Psr\Log\NullLogger;
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');
}
* @small
* @dataProvider dataSimple
*/
- function testCompareSet($value1, $value2) {
+ function testCompareSet($value1, $value2)
+ {
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
* @small
* @dataProvider dataSimple
*/
- function testNegativeCompareSet($value1, $value2) {
+ function testNegativeCompareSet($value1, $value2)
+ {
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
* @small
* @dataProvider dataSimple
*/
- function testCompareDelete($data) {
+ function testCompareDelete($data)
+ {
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data);
* @small
* @dataProvider dataSimple
*/
- function testNegativeCompareDelete($data) {
+ function testNegativeCompareDelete($data)
+ {
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data);
* @small
* @dataProvider dataSimple
*/
- function testAdd($value1, $value2) {
+ function testAdd($value1, $value2)
+ {
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
$this->assertEquals($value2, $received, 'Value was not overwritten by add');
$this->assertNotEquals($value1, $received, 'Value was not overwritten by any other value');
}
-}
\ No newline at end of file
+}
namespace Friendica\Test\src\Core\Cache;
-use Friendica\Factory\CacheDriverFactory;
+use Friendica\Core\Cache\RedisCacheDriver;
+use Friendica\Core\Config\Configuration;
/**
* @requires extension redis
{
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;
}
namespace Friendica\Test\src\Core\Lock;
-
use Friendica\Core\Cache\APCuCache;
use Friendica\Core\Lock\CacheLockDriver;
protected function getInstance()
{
- return new CacheLockDriver(new APCuCache());
+ return new CacheLockDriver(new APCuCache('localhost'));
}
}
namespace Friendica\Test\src\Core\Lock;
-
use Friendica\Core\Cache\ArrayCache;
use Friendica\Core\Lock\CacheLockDriver;
{
protected function getInstance()
{
- return new CacheLockDriver(new ArrayCache());
+ return new CacheLockDriver(new ArrayCache('localhost'));
}
public function testLockTTL()
namespace Friendica\Test\src\Core\Lock;
-use Friendica\Core\Cache;
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
{
- use DbaLockMockTrait;
+ use VFSTrait;
+ use DatabaseTestTrait;
protected $pid = 123;
protected function setUp()
{
- $this->mockConnected();
- $this->mockConnect();
-
- $this->mockReleaseAll($this->pid, 2);
+ $this->setUpVfsDir();
parent::setUp();
}
protected function getInstance()
{
- return new DatabaseLockDriver($this->pid);
- }
-
- public function testLock()
- {
- $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->mockIsLocked('bar', false, $this->startTime, 1);
-
- parent::testLock();
- }
-
- public function testDoubleLock()
- {
- $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);
+ $logger = new NullLogger();
+ $profiler = \Mockery::mock(Profiler::class);
+ $profiler->shouldReceive('saveTimestamp')->withAnyArgs()->andReturn(true);
- $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);
+ // 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);
- $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);
+ $dba = new StaticDatabase($configCache, $profiler, $logger);
- parent::testReleaseWitTTL();
+ return new DatabaseLockDriver($dba, $this->pid);
}
}
namespace Friendica\Test\src\Core\Lock;
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
{
- use VFSTrait;
- use AppMockTrait;
-
/**
* @var int Start time of the mock (used for time operations)
*/
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();
+
$this->instance = $this->getInstance();
$this->instance->releaseAll();
}
/**
* @small
*/
- public function testLock() {
+ public function testLock()
+ {
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
/**
* @small
*/
- public function testDoubleLock() {
+ public function testDoubleLock()
+ {
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
/**
* @small
*/
- public function testReleaseLock() {
+ public function testReleaseLock()
+ {
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
/**
* @small
*/
- public function testReleaseAll() {
+ public function testReleaseAll()
+ {
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->acquireLock('bar', 1));
$this->assertTrue($this->instance->acquireLock('nice', 1));
/**
* @small
*/
- public function testReleaseAfterUnlock() {
+ public function testReleaseAfterUnlock()
+ {
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar'));
$this->assertFalse($this->instance->isLocked('nice'));
/**
* @medium
*/
- function testLockTTL() {
+ function testLockTTL()
+ {
$this->markTestSkipped('taking too much time without mocking');
$this->assertFalse($this->instance->isLocked('foo'));
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;
/**
{
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);
- return new CacheLockDriver(CacheDriverFactory::create('memcache'));
+ return new CacheLockDriver(new MemcacheCacheDriver('localhost', $configMock));
}
}
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 Psr\Log\NullLogger;
/**
* @requires extension memcached
{
protected function getInstance()
{
- $this->configMock
+ $configMock = \Mockery::mock(Configuration::class);
+
+ $configMock
->shouldReceive('get')
->with('system', 'memcached_hosts')
->andReturn([0 => 'localhost, 11211']);
- return new CacheLockDriver(CacheDriverFactory::create('memcached'));
+ $logger = new NullLogger();
+
+ return new CacheLockDriver(new MemcachedCacheDriver('localhost', $configMock, $logger));
}
}
namespace Friendica\Test\src\Core\Lock;
+use Friendica\Core\Cache\RedisCacheDriver;
+use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\CacheLockDriver;
-use Friendica\Factory\CacheDriverFactory;
/**
* @requires extension redis
{
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);
- return new CacheLockDriver(CacheDriverFactory::create('redis'));
+ return new CacheLockDriver(new RedisCacheDriver('localhost', $configMock));
}
}
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;
class SemaphoreLockDriverTest extends LockTest
{
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')
- ->with('system', 'temppath')
+ ->with('system', 'temppath', NULL, false)
->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()
projects / friendica.git / commitdiff