define('FRIENDICA_CODENAME', 'The Tazmans Flax-lily');
define('FRIENDICA_VERSION', '2018.08-dev');
define('DFRN_PROTOCOL_VERSION', '2.23');
-define('DB_UPDATE_VERSION', 1272);
+define('DB_UPDATE_VERSION', 1273);
define('NEW_UPDATE_ROUTINE_VERSION', 1170);
/**
--- /dev/null
+<?php
+
+namespace Friendica\Core\Cache;
+
+
+use Friendica\Core\Cache;
+
+/**
+ * @brief Implementation of the IMemoryCacheDriver mainly for testing purpose
+ *
+ * Class ArrayCache
+ *
+ * @package Friendica\Core\Cache
+ */
+class ArrayCache implements IMemoryCacheDriver
+{
+ use TraitCompareDelete;
+
+ /** @var array Array with the cached data */
+ protected $cachedData = array();
+
+ /**
+ * (@inheritdoc)
+ */
+ public function get($key)
+ {
+ if (isset($this->cachedData[$key])) {
+ return $this->cachedData[$key];
+ }
+ return null;
+ }
+
+ /**
+ * (@inheritdoc)
+ */
+ public function set($key, $value, $ttl = Cache::FIVE_MINUTES)
+ {
+ $this->cachedData[$key] = $value;
+ return true;
+ }
+
+ /**
+ * (@inheritdoc)
+ */
+ public function delete($key)
+ {
+ unset($this->cachedData[$key]);
+ return true;
+ }
+
+ /**
+ * (@inheritdoc)
+ */
+ public function clear()
+ {
+ $this->cachedData = [];
+ return true;
+ }
+
+ /**
+ * (@inheritdoc)
+ */
+ public function add($key, $value, $ttl = Cache::FIVE_MINUTES)
+ {
+ if (isset($this->cachedData[$key])) {
+ return false;
+ } else {
+ return $this->set($key, $value, $ttl);
+ }
+ }
+
+ /**
+ * (@inheritdoc)
+ */
+ public function compareSet($key, $oldValue, $newValue, $ttl = Cache::FIVE_MINUTES)
+ {
+ if ($this->get($key) === $oldValue) {
+ return $this->set($key, $newValue);
+ } else {
+ return false;
+ }
+ }
+}
\ No newline at end of file
return null;
}
- public function set($key, $value, $duration = Cache::MONTH)
+ public function set($key, $value, $ttl = Cache::FIVE_MINUTES)
{
$fields = [
'v' => serialize($value),
- 'expires' => DateTimeFormat::utc('now + ' . $duration . ' seconds'),
+ 'expires' => DateTimeFormat::utc('now + ' . $ttl . ' seconds'),
'updated' => DateTimeFormat::utcNow()
];
interface ICacheDriver
{
/**
- * Fetches cached data according to the key
+ * @brief Fetches cached data according to the key
*
* @param string $key The key to the cached data
*
public function get($key);
/**
- * Stores data in the cache identified by the key. The input $value can have multiple formats.
+ * @brief Stores data in the cache identified by the key. The input $value can have multiple formats.
*
* @param string $key The cache key
* @param mixed $value The value to store
- * @param integer $duration The cache lifespan, must be one of the Cache constants
+ * @param integer $ttl The cache lifespan, must be one of the Cache constants
*
* @return bool
*/
- public function set($key, $value, $duration = Cache::MONTH);
-
+ public function set($key, $value, $ttl = Cache::FIVE_MINUTES);
/**
- * Delete a key from the cache
+ * @brief Delete a key from the cache
*
- * @param string $key
+ * @param string $key The cache key
*
* @return bool
*/
public function delete($key);
/**
- * Remove outdated data from the cache
+ * @brief Remove outdated data from the cache
*
* @return bool
*/
--- /dev/null
+<?php
+
+namespace Friendica\Core\Cache;
+use Friendica\Core\Cache;
+
+/**
+ * @brief This interface defines methods for Memory-Caches only
+ *
+ * Interface IMemoryCacheDriver
+ *
+ * @package Friendica\Core\Cache
+ */
+interface IMemoryCacheDriver extends ICacheDriver
+{
+ /**
+ * @brief Sets a value if it's not already stored
+ *
+ * @param string $key The cache key
+ * @param mixed $value The old value we know from the cache
+ * @param int $ttl The cache lifespan, must be one of the Cache constants
+ * @return bool
+ */
+ public function add($key, $value, $ttl = Cache::FIVE_MINUTES);
+
+ /**
+ * @brief Compares if the old value is set and sets the new value
+ *
+ * @param string $key The cache key
+ * @param mixed $oldValue The old value we know from the cache
+ * @param mixed $newValue The new value we want to set
+ * @param int $ttl The cache lifespan, must be one of the Cache constants
+ *
+ * @return bool
+ */
+ public function compareSet($key, $oldValue, $newValue, $ttl = Cache::FIVE_MINUTES);
+
+ /**
+ * @brief Compares if the old value is set and removes it
+ *
+ * @param string $key The cache key
+ * @param mixed $value The old value we know and want to delete
+ * @return bool
+ */
+ public function compareDelete($key, $value);
+}
\ No newline at end of file
*
* @author Hypolite Petovan <mrpetovan@gmail.com>
*/
-class MemcacheCacheDriver extends BaseObject implements ICacheDriver
+class MemcacheCacheDriver extends BaseObject implements IMemoryCacheDriver
{
+ use TraitCompareSet;
+ use TraitCompareDelete;
+
/**
- * @var Memcache
+ * @var \Memcache
*/
private $memcache;
}
}
+ /**
+ * (@inheritdoc)
+ */
public function get($key)
{
$return = null;
return $return;
}
- public function set($key, $value, $duration = Cache::MONTH)
+ /**
+ * (@inheritdoc)
+ */
+ public function set($key, $value, $ttl = Cache::FIVE_MINUTES)
{
// We store with the hostname as key to avoid problems with other applications
- return $this->memcache->set(
- self::getApp()->get_hostname() . ":" . $key,
- serialize($value),
- MEMCACHE_COMPRESSED,
- time() + $duration
- );
+ if ($ttl > 0) {
+ return $this->memcache->set(
+ self::getApp()->get_hostname() . ":" . $key,
+ serialize($value),
+ MEMCACHE_COMPRESSED,
+ time() + $ttl
+ );
+ } else {
+ return $this->memcache->set(
+ self::getApp()->get_hostname() . ":" . $key,
+ serialize($value),
+ MEMCACHE_COMPRESSED
+ );
+ }
}
+ /**
+ * (@inheritdoc)
+ */
public function delete($key)
{
return $this->memcache->delete($key);
public function clear()
{
- return true;
+ return $this->memcache->flush();
+ }
+
+ /**
+ * (@inheritdoc)
+ */
+ public function add($key, $value, $ttl = Cache::FIVE_MINUTES)
+ {
+ return $this->memcache->add(self::getApp()->get_hostname() . ":" . $key, $value, $ttl);
}
}
*
* @author Hypolite Petovan <mrpetovan@gmail.com>
*/
-class MemcachedCacheDriver extends BaseObject implements ICacheDriver
+class MemcachedCacheDriver extends BaseObject implements IMemoryCacheDriver
{
+ use TraitCompareSet;
+ use TraitCompareDelete;
+
/**
* @var Memcached
*/
return $return;
}
- public function set($key, $value, $duration = Cache::MONTH)
+ public function set($key, $value, $ttl = Cache::FIVE_MINUTES)
{
// We store with the hostname as key to avoid problems with other applications
- return $this->memcached->set(
- self::getApp()->get_hostname() . ':' . $key,
- $value,
- time() + $duration
- );
+ if ($ttl > 0) {
+ return $this->memcached->set(
+ self::getApp()->get_hostname() . ':' . $key,
+ $value,
+ time() + $ttl
+ );
+ } else {
+ return $this->memcached->set(
+ self::getApp()->get_hostname() . ':' . $key,
+ $value
+ );
+ }
+
}
public function delete($key)
{
return true;
}
+
+ /**
+ * @brief Sets a value if it's not already stored
+ *
+ * @param string $key The cache key
+ * @param mixed $value The old value we know from the cache
+ * @param int $ttl The cache lifespan, must be one of the Cache constants
+ * @return bool
+ */
+ public function add($key, $value, $ttl = Cache::FIVE_MINUTES)
+ {
+ return $this->memcached->add(self::getApp()->get_hostname() . ":" . $key, $value, $ttl);
+ }
}
* @author Hypolite Petovan <mrpetovan@gmail.com>
* @author Roland Haeder <roland@mxchange.org>
*/
-class RedisCacheDriver extends BaseObject implements ICacheDriver
+class RedisCacheDriver extends BaseObject implements IMemoryCacheDriver
{
/**
* @var Redis
return $return;
}
- public function set($key, $value, $duration = Cache::MONTH)
+ public function set($key, $value, $ttl = Cache::FIVE_MINUTES)
{
// We store with the hostname as key to avoid problems with other applications
- return $this->redis->set(
- self::getApp()->get_hostname() . ":" . $key,
- serialize($value),
- time() + $duration
- );
+ if ($ttl > 0) {
+ return $this->redis->setex(
+ self::getApp()->get_hostname() . ":" . $key,
+ time() + $ttl,
+ serialize($value)
+ );
+ } else {
+ return $this->redis->set(
+ self::getApp()->get_hostname() . ":" . $key,
+ serialize($value)
+ );
+ }
}
public function delete($key)
{
return true;
}
+
+
+ /**
+ * @brief Sets a value if it's not already stored
+ *
+ * @param string $key The cache key
+ * @param mixed $value The old value we know from the cache
+ * @param int $ttl The cache lifespan, must be one of the Cache constants
+ * @return bool
+ */
+ public function add($key, $value, $ttl = Cache::FIVE_MINUTES)
+ {
+ if (!is_int($value)) {
+ $value = serialize($value);
+ }
+
+ return $this->redis->setnx(self::getApp()->get_hostname() . ":" . $key, $value);
+ }
+
+ /**
+ * @brief Compares if the old value is set and sets the new value
+ *
+ * @param string $key The cache key
+ * @param mixed $oldValue The old value we know
+ * @param mixed $newValue The new value we want to set
+ * @param int $ttl The cache lifespan, must be one of the Cache constants
+ * @return bool
+ */
+ public function compareSet($key, $oldValue, $newValue, $ttl = Cache::FIVE_MINUTES)
+ {
+ if (!is_int($newValue)) {
+ $newValue = serialize($newValue);
+ }
+
+ $this->redis->watch(self::getApp()->get_hostname() . ":" . $key);
+ // If the old value isn't what we expected, somebody else changed the key meanwhile
+ if ($this->get($key) === $oldValue) {
+ if ($ttl > 0) {
+ $result = $this->redis->multi()
+ ->setex(self::getApp()->get_hostname() . ":" . $ttl, $key, $newValue)
+ ->exec();
+ } else {
+ $result = $this->redis->multi()
+ ->set(self::getApp()->get_hostname() . ":" . $key, $newValue)
+ ->exec();
+ }
+ return $result !== false;
+ }
+ $this->redis->unwatch();
+ return false;
+ }
+ /**
+ * @brief Compares if the old value is set and removes it
+ *
+ * @param string $key The cache key
+ * @param mixed $value The old value we know and want to delete
+ * @return bool
+ */
+ public function compareDelete($key, $value)
+ {
+ $this->redis->watch(self::getApp()->get_hostname() . ":" . $key);
+ // If the old value isn't what we expected, somebody else changed the key meanwhile
+ if ($this->get($key) === $value) {
+ $result = $this->redis->multi()
+ ->del(self::getApp()->get_hostname() . ":" . $key)
+ ->exec();
+ return $result !== false;
+ }
+ $this->redis->unwatch();
+ return false;
+ }
}
--- /dev/null
+<?php
+
+namespace Friendica\Core\Cache;
+
+use Friendica\Core\Cache;
+
+/**
+ * Trait TraitCompareSetDelete
+ *
+ * @brief This Trait is to compensate non native "exclusive" sets/deletes in caches
+ *
+ * @package Friendica\Core\Cache
+ */
+trait TraitCompareDelete
+{
+ abstract public function get($key);
+
+ abstract public function set($key, $value, $ttl = Cache::FIVE_MINUTES);
+
+ abstract public function delete($key);
+
+ abstract public function add($key, $value, $ttl = Cache::FIVE_MINUTES);
+
+ /**
+ * @brief NonNative - Compares if the old value is set and removes it
+ *
+ * @param string $key The cache key
+ * @param mixed $value The old value we know and want to delete
+ * @return bool
+ */
+ public function compareDelete($key, $value) {
+ if ($this->add($key . "_lock", true)) {
+ if ($this->get($key) === $value) {
+ $this->delete($key);
+ $this->delete($key . "_lock");
+ return true;
+ } else {
+ $this->delete($key . "_lock");
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+<?php
+
+namespace Friendica\Core\Cache;
+
+use Friendica\Core\Cache;
+
+/**
+ * Trait TraitCompareSetDelete
+ *
+ * @brief This Trait is to compensate non native "exclusive" sets/deletes in caches
+ *
+ * @package Friendica\Core\Cache
+ */
+trait TraitCompareSet
+{
+ abstract public function get($key);
+
+ abstract public function set($key, $value, $ttl = Cache::FIVE_MINUTES);
+
+ abstract public function delete($key);
+
+ abstract public function add($key, $value, $ttl = Cache::FIVE_MINUTES);
+
+ /**
+ * @brief NonNative - Compares if the old value is set and sets the new value
+ *
+ * @param string $key The cache key
+ * @param mixed $oldValue The old value we know from the cache
+ * @param mixed $newValue The new value we want to set
+ * @param int $ttl The cache lifespan, must be one of the Cache constants
+ *
+ * @return bool
+ */
+ public function compareSet($key, $oldValue, $newValue, $ttl = Cache::FIVE_MINUTES) {
+ if ($this->add($key . "_lock", true)) {
+ if ($this->get($key) === $oldValue) {
+ $this->set($key, $newValue, $ttl);
+ $this->delete($key . "_lock");
+ return true;
+ } else {
+ $this->delete($key . "_lock");
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+}
\ No newline at end of file
*/
use Friendica\Core\Cache\CacheDriverFactory;
+use Friendica\Core\Cache\IMemoryCacheDriver;
/**
* @brief This class contain Functions for preventing parallel execution of functions
switch ($lock_driver) {
case 'memcache':
$cache_driver = CacheDriverFactory::create('memcache');
- self::$driver = new Lock\CacheLockDriver($cache_driver);
+ if ($cache_driver instanceof IMemoryCacheDriver) {
+ self::$driver = new Lock\CacheLockDriver($cache_driver);
+ }
break;
case 'memcached':
$cache_driver = CacheDriverFactory::create('memcached');
- self::$driver = new Lock\CacheLockDriver($cache_driver);
+ if ($cache_driver instanceof IMemoryCacheDriver) {
+ self::$driver = new Lock\CacheLockDriver($cache_driver);
+ }
break;
case 'redis':
$cache_driver = CacheDriverFactory::create('redis');
- self::$driver = new Lock\CacheLockDriver($cache_driver);
+ if ($cache_driver instanceof IMemoryCacheDriver) {
+ self::$driver = new Lock\CacheLockDriver($cache_driver);
+ }
break;
case 'database':
if ($cache_driver != 'database') {
try {
$lock_driver = CacheDriverFactory::create($cache_driver);
- self::$driver = new Lock\CacheLockDriver($lock_driver);
+ if ($lock_driver instanceof IMemoryCacheDriver) {
+ self::$driver = new Lock\CacheLockDriver($lock_driver);
+ }
return;
} catch (\Exception $exception) {
logger('Using Cache driver for locking failed: ' . $exception->getMessage());
<?php
namespace Friendica\Core\Lock;
+use Friendica\BaseObject;
/**
* Class AbstractLockDriver
*
* @brief Basic class for Locking with common functions (local acquired locks, releaseAll, ..)
*/
-abstract class AbstractLockDriver implements ILockDriver
+abstract class AbstractLockDriver extends BaseObject implements ILockDriver
{
/**
* @var array The local acquired locks
* @return bool Returns true if the lock is set
*/
protected function hasAcquiredLock($key) {
- return isset($this->acquireLock[$key]);
+ return isset($this->acquireLock[$key]) && $this->acquiredLocks[$key] === true;
}
/**
* @return void
*/
public function releaseAll() {
- foreach ($this->acquiredLocks as $acquiredLock) {
+ foreach ($this->acquiredLocks as $acquiredLock => $hasLock) {
$this->releaseLock($acquiredLock);
}
}
namespace Friendica\Core\Lock;
-use Friendica\Core\Cache\ICacheDriver;
+use Friendica\Core\Cache\IMemoryCacheDriver;
class CacheLockDriver extends AbstractLockDriver
{
/**
* CacheLockDriver constructor.
*
- * @param ICacheDriver $cache The CacheDriver for this type of lock
+ * @param IMemoryCacheDriver $cache The CacheDriver for this type of lock
*/
- public function __construct(ICacheDriver $cache)
+ public function __construct(IMemoryCacheDriver $cache)
{
$this->cache = $cache;
}
$got_lock = false;
$start = time();
- $cachekey = get_app()->get_hostname() . ";lock:" . $key;
+ $cachekey = self::getCacheKey($key);
do {
$lock = $this->cache->get($cachekey);
+ // When we do want to lock something that was already locked by us.
+ if ((int)$lock == getmypid()) {
+ $got_lock = true;
+ }
- if (!is_bool($lock)) {
- $pid = (int)$lock;
-
- // When the process id isn't used anymore, we can safely claim the lock for us.
- // Or we do want to lock something that was already locked by us.
- if (!posix_kill($pid, 0) || ($pid == getmypid())) {
- $lock = false;
+ // When we do want to lock something new
+ if (is_null($lock)) {
+ // At first initialize it with "0"
+ $this->cache->add($cachekey, 0);
+ // Now the value has to be "0" because otherwise the key was used by another process meanwhile
+ if ($this->cache->compareSet($cachekey, 0, getmypid(), 300)) {
+ $got_lock = true;
+ $this->markAcquire($key);
}
}
- if (is_bool($lock)) {
- $this->cache->set($cachekey, getmypid(), 300);
- $got_lock = true;
- }
if (!$got_lock && ($timeout > 0)) {
usleep(rand(10000, 200000));
}
} while (!$got_lock && ((time() - $start) < $timeout));
- $this->markAcquire($key);
-
return $got_lock;
}
* @brief Removes a lock if it was set by us
*
* @param string $key Name of the lock
- *
- * @return mixed
*/
public function releaseLock($key)
{
- $cachekey = get_app()->get_hostname() . ";lock:" . $key;
- $lock = $this->cache->get($cachekey);
-
- if (!is_bool($lock)) {
- if ((int)$lock == getmypid()) {
- $this->cache->delete($cachekey);
- }
- }
+ $cachekey = self::getCacheKey($key);
+ $this->cache->compareDelete($cachekey, getmypid());
$this->markRelease($key);
+ }
- return;
+ /**
+ * @brief Checks, if a key is currently locked to a process
+ *
+ * @param string $key The name of the lock
+ * @return bool
+ */
+ public function isLocked($key)
+ {
+ $cachekey = self::getCacheKey($key);
+ $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
+ */
+ private static function getCacheKey($key) {
+ return self::getApp()->get_hostname() . ";lock:" . $key;
}
}
use dba;
use Friendica\Database\DBM;
+use Friendica\Util\DateTimeFormat;
/**
* Locking driver that stores the locks in the database
class DatabaseLockDriver extends AbstractLockDriver
{
/**
- * @brief Sets a lock for a given name
- *
- * @param string $key The Name of the lock
- * @param integer $timeout Seconds until we give up
- *
- * @return boolean Was the lock successful?
+ * (@inheritdoc)
*/
public function acquireLock($key, $timeout = 120)
{
do {
dba::lock('locks');
- $lock = dba::selectFirst('locks', ['locked', 'pid'], ['name' => $key]);
+ $lock = dba::selectFirst('locks', ['locked', 'pid'], ['`name` = ? AND `expires` >= ?', $key, DateTimeFormat::utcNow()]);
if (DBM::is_result($lock)) {
if ($lock['locked']) {
- // When the process id isn't used anymore, we can safely claim the lock for us.
- if (!posix_kill($lock['pid'], 0)) {
- $lock['locked'] = false;
- }
// We want to lock something that was already locked by us? So we got the lock.
if ($lock['pid'] == getmypid()) {
$got_lock = true;
+ $this->markAcquire($key);
}
}
if (!$lock['locked']) {
- dba::update('locks', ['locked' => true, 'pid' => getmypid()], ['name' => $key]);
+ dba::update('locks', ['locked' => true, 'pid' => getmypid(), 'expires' => DateTimeFormat::utc('now + 300seconds')], ['name' => $key]);
$got_lock = true;
+ $this->markAcquire($key);
}
} else {
- dba::insert('locks', ['name' => $key, 'locked' => true, 'pid' => getmypid()]);
+ dba::insert('locks', ['name' => $key, 'locked' => true, 'pid' => getmypid(), 'expires' => DateTimeFormat::utc('now + 300seconds')]);
$got_lock = true;
+ $this->markAcquire($key);
}
dba::unlock();
}
} while (!$got_lock && ((time() - $start) < $timeout));
- $this->markAcquire($key);
-
return $got_lock;
}
/**
- * @brief Removes a lock if it was set by us
- *
- * @param string $key Name of the lock
- *
- * @return mixed
+ * (@inheritdoc)
*/
public function releaseLock($key)
{
- dba::delete('locks', ['locked' => false, 'pid' => 0], ['name' => $key, 'pid' => getmypid()]);
+ dba::delete('locks', ['name' => $key, 'pid' => getmypid()]);
- $this->releaseLock($key);
+ $this->markRelease($key);
return;
}
/**
- * @brief Removes all lock that were set by us
- *
- * @return void
+ * (@inheritdoc)
*/
public function releaseAll()
{
- dba::delete('locks', ['locked' => false, 'pid' => 0], ['pid' => getmypid()]);
+ dba::delete('locks', ['pid' => getmypid()]);
$this->acquiredLocks = [];
}
+
+ /**
+ * (@inheritdoc)
+ */
+ public function isLocked($key)
+ {
+ $lock = dba::selectFirst('locks', ['locked'], ['`name` = ? AND `expires` >= ?', $key, DateTimeFormat::utcNow()]);
+
+ if (DBM::is_result($lock)) {
+ return $lock['locked'] !== false;
+ } else {
+ return false;
+ }
+ }
}
*/
interface ILockDriver
{
+ /**
+ * @brief Checks, if a key is currently locked to a or my process
+ *
+ * @param string $key The name of the lock
+ * @return bool
+ */
+ public function isLocked($key);
+
/**
*
* @brief Acquires a lock for a given name
class SemaphoreLockDriver extends AbstractLockDriver
{
+ private static $semaphore = [];
+
public function __construct()
{
if (!function_exists('sem_get')) {
*/
public function acquireLock($key, $timeout = 120)
{
- $this->acquiredLocks[$key] = sem_get(self::semaphoreKey($key));
- if ($this->acquiredLocks[$key]) {
- return sem_acquire($this->acquiredLocks[$key], ($timeout == 0));
+ self::$semaphore[$key] = sem_get(self::semaphoreKey($key));
+ if (self::$semaphore[$key]) {
+ if (sem_acquire(self::$semaphore[$key], ($timeout == 0))) {
+ $this->markAcquire($key);
+ return true;
+ }
}
+
+ return false;
}
/**
*/
public function releaseLock($key)
{
- if (empty($this->acquiredLocks[$key])) {
+ if (empty(self::$semaphore[$key])) {
return false;
} else {
- $success = @sem_release($this->acquiredLocks[$key]);
- unset($this->acquiredLocks[$key]);
+ $success = @sem_release(self::$semaphore[$key]);
+ unset(self::$semaphore[$key]);
+ $this->markRelease($key);
return $success;
}
}
+
+ /**
+ * @brief Checks, if a key is currently locked to a process
+ *
+ * @param string $key The name of the lock
+ * @return bool
+ */
+ public function isLocked($key)
+ {
+ return @sem_get(self::$semaphore[$key]) !== false;
+ }
}
*/
namespace Friendica\Database;
+use dba;
use Friendica\Core\Config;
use Friendica\Core\L10n;
-use Friendica\Database\DBM;
-use dba;
require_once 'boot.php';
require_once 'include/dba.php';
"name" => ["type" => "varchar(128)", "not null" => "1", "default" => "", "comment" => ""],
"locked" => ["type" => "boolean", "not null" => "1", "default" => "0", "comment" => ""],
"pid" => ["type" => "int unsigned", "not null" => "1", "default" => "0", "comment" => "Process ID"],
- ],
+ "expires" => ["type" => "datetime", "not null" => "1", "default" => NULL_DATE, "comment" => "datetime of cache expiration"],
+ ],
"indexes" => [
"PRIMARY" => ["id"],
+ "name_expires" => ["name", "expires"]
]
];
$database["mail"] = [
uid: 42
username: Test user
nickname: selfcontact
- verified: true
+ verified: 1
password: $2y$10$DLRNTRmJgKe1cSrFJ5Jb0edCqvXlA9sh/RHdSnfxjbR.04yZRm4Qm
theme: frio
uid: 42
name: Self contact
nick: selfcontact
- self: true
+ self: 1
nurl: http://localhost/profile/selfcontact
url: http://localhost/profile/selfcontact
about: User used in tests
- pending: false
- blocked: false
+ pending: 0
+ blocked: 0
rel: 1
network: dfrn
-
# the fallback to api_get_nick() in api_get_user()
name: othercontact
nick: othercontact
- self: false
+ self: 0
nurl: http://localhost/profile/othercontact
url: http://localhost/profile/othercontact
- pending: false
- blocked: false
+ pending: 0
+ blocked: 0
rel: 0
network: dfrn
-
uid: 0
name: Friend contact
nick: friendcontact
- self: false
+ self: 0
nurl: http://localhost/profile/friendcontact
url: http://localhost/profile/friendcontact
- pending: false
- blocked: false
+ pending: 0
+ blocked: 0
rel: 2
network: dfrn
item:
-
id: 1
- visible: true
+ visible: 1
contact-id: 42
author-id: 42
owner-id: 45
uid: 42
verb: http://activitystrea.ms/schema/1.0/post
- unseen: true
+ unseen: 1
body: Parent status
parent: 1
author-link: http://localhost/profile/selfcontact
- wall: true
- starred: true
- origin: true
+ wall: 1
+ starred: 1
+ origin: 1
allow_cid: ''
allow_gid: ''
deny_cid: ''
deny_gid: ''
-
id: 2
- visible: true
+ visible: 1
contact-id: 42
author-id: 42
owner-id: 45
uid: 42
verb: http://activitystrea.ms/schema/1.0/post
- unseen: false
+ unseen: 0
body: Reply
parent: 1
author-link: http://localhost/profile/selfcontact
- wall: true
- starred: false
- origin: true
+ wall: 1
+ starred: 0
+ origin: 1
-
id: 3
- visible: true
+ visible: 1
contact-id: 43
author-id: 43
owner-id: 42
uid: 42
verb: http://activitystrea.ms/schema/1.0/post
- unseen: false
+ unseen: 0
body: Other user status
parent: 3
author-link: http://localhost/profile/othercontact
- wall: true
- starred: false
- origin: true
+ wall: 1
+ starred: 0
+ origin: 1
-
id: 4
- visible: true
+ visible: 1
contact-id: 44
author-id: 44
owner-id: 42
uid: 42
verb: http://activitystrea.ms/schema/1.0/post
- unseen: false
+ unseen: 0
body: Friend user reply
parent: 1
author-link: http://localhost/profile/othercontact
- wall: true
- starred: false
- origin: true
+ wall: 1
+ starred: 0
+ origin: 1
-
id: 5
- visible: true
+ visible: 1
contact-id: 42
author-id: 42
owner-id: 42
uid: 42
verb: http://activitystrea.ms/schema/1.0/post
- unseen: false
+ unseen: 0
body: '[share]Shared status[/share]'
parent: 1
author-link: http://localhost/profile/othercontact
- wall: true
- starred: false
- origin: true
+ wall: 1
+ starred: 0
+ origin: 1
allow_cid: ''
allow_gid: ''
deny_cid: ''
deny_gid: ''
-
id: 6
- visible: true
+ visible: 1
contact-id: 44
author-id: 44
owner-id: 42
uid: 42
verb: http://activitystrea.ms/schema/1.0/post
- unseen: false
+ unseen: 0
body: Friend user status
parent: 6
author-link: http://localhost/profile/othercontact
- wall: true
- starred: false
- origin: true
+ wall: 1
+ starred: 0
+ origin: 1
thread:
-
iid: 1
- visible: true
+ visible: 1
contact-id: 42
author-id: 42
owner-id: 42
uid: 42
- wall: true
+ wall: 1
-
iid: 3
- visible: true
+ visible: 1
contact-id: 43
author-id: 43
owner-id: 43
uid: 0
- wall: true
+ wall: 1
-
iid: 6
- visible: true
+ visible: 1
contact-id: 44
author-id: 44
owner-id: 44
uid: 0
- wall: true
+ wall: 1
group:
-
id: 1
uid: 42
- visible: true
+ visible: 1
name: Visible list
-
id: 2
uid: 42
- visible: false
+ visible: 0
name: Private list
search:
--- /dev/null
+<?php
+
+namespace Friendica\Test\src\Core\Lock;
+
+
+use Friendica\Core\Cache\ArrayCache;
+use Friendica\Core\Lock\CacheLockDriver;
+
+class CacheLockDriverTest extends LockTest
+{
+ /**
+ * @var \Friendica\Core\Cache\IMemoryCacheDriver
+ */
+ private $cache;
+
+ protected function getInstance()
+ {
+ $this->cache = new ArrayCache();
+ return new CacheLockDriver($this->cache);
+ }
+
+ public function tearDown()
+ {
+ $this->cache->clear();
+ parent::tearDown();
+ }
+}
\ No newline at end of file
--- /dev/null
+<?php
+
+namespace Friendica\Test\src\Core\Lock;
+
+use dba;
+use Friendica\Core\Lock\DatabaseLockDriver;
+use Friendica\Database\DBStructure;
+use PHPUnit\DbUnit\DataSet\YamlDataSet;
+use PHPUnit\DbUnit\TestCaseTrait;
+use PHPUnit_Extensions_Database_DB_IDatabaseConnection;
+
+class DatabaseLockDriverTest extends LockTest
+{
+ use TestCaseTrait;
+
+ /**
+ * Get database connection.
+ *
+ * This function is executed before each test in order to get a database connection that can be used by tests.
+ * If no prior connection is available, it tries to create one using the USER, PASS and DB environment variables.
+ *
+ * If it could not connect to the database, the test is skipped.
+ *
+ * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection
+ * @see https://phpunit.de/manual/5.7/en/database.html
+ */
+ protected function getConnection()
+ {
+ if (!dba::$connected) {
+ dba::connect('localhost', getenv('USER'), getenv('PASS'), getenv('DB'));
+
+ if (dba::$connected) {
+ $app = get_app();
+ // We need to do this in order to disable logging
+ $app->module = 'install';
+
+ // Create database structure
+ DBStructure::update(false, true, true);
+ } else {
+ $this->markTestSkipped('Could not connect to the database.');
+ }
+ }
+
+ return $this->createDefaultDBConnection(dba::get_db(), getenv('DB'));
+ }
+
+ /**
+ * Get dataset to populate the database with.
+ * @return YamlDataSet
+ * @see https://phpunit.de/manual/5.7/en/database.html
+ */
+ protected function getDataSet()
+ {
+ return new YamlDataSet(__DIR__ . '/../../../datasets/api.yml');
+ }
+
+ protected function getInstance()
+ {
+ return new DatabaseLockDriver();
+ }
+
+ public function tearDown()
+ {
+ dba::delete('locks', [ 'id > 0']);
+ parent::tearDown();
+ }
+}
\ No newline at end of file
--- /dev/null
+<?php
+
+namespace Friendica\Test\src\Core\Lock;
+
+use Friendica\App;
+use Friendica\Core\Config;
+use PHPUnit\Framework\TestCase;
+
+abstract class LockTest extends TestCase
+{
+ /**
+ * @var \Friendica\Core\Lock\ILockDriver
+ */
+ protected $instance;
+
+ abstract protected function getInstance();
+
+ protected function setUp()
+ {
+ global $a;
+ parent::setUp();
+ $this->instance = $this->getInstance();
+
+ // Reusable App object
+ $this->app = new App(__DIR__.'/../');
+ $a = $this->app;
+
+ // Default config
+ Config::set('config', 'hostname', 'localhost');
+ Config::set('system', 'throttle_limit_day', 100);
+ Config::set('system', 'throttle_limit_week', 100);
+ Config::set('system', 'throttle_limit_month', 100);
+ Config::set('system', 'theme', 'system_theme');
+ }
+
+ public function testLock() {
+ $this->instance->acquireLock('foo', 1);
+ $this->assertTrue($this->instance->isLocked('foo'));
+ $this->assertFalse($this->instance->isLocked('bar'));
+ }
+
+ public function testDoubleLock() {
+ $this->instance->acquireLock('foo', 1);
+ $this->assertTrue($this->instance->isLocked('foo'));
+ // We already locked it
+ $this->assertTrue($this->instance->acquireLock('foo', 1));
+ }
+
+ public function testReleaseLock() {
+ $this->instance->acquireLock('foo', 1);
+ $this->assertTrue($this->instance->isLocked('foo'));
+ $this->instance->releaseLock('foo');
+ $this->assertFalse($this->instance->isLocked('foo'));
+ }
+
+ public function testReleaseAll() {
+ $this->instance->acquireLock('foo', 1);
+ $this->instance->acquireLock('bar', 1);
+ $this->instance->acquireLock('#/$%§', 1);
+
+ $this->instance->releaseAll();
+
+ $this->assertFalse($this->instance->isLocked('foo'));
+ $this->assertFalse($this->instance->isLocked('bar'));
+ $this->assertFalse($this->instance->isLocked('#/$%§'));
+ }
+
+ public function testReleaseAfterUnlock() {
+ $this->instance->acquireLock('foo', 1);
+ $this->instance->acquireLock('bar', 1);
+ $this->instance->acquireLock('#/$%§', 1);
+
+ $this->instance->releaseLock('foo');
+
+ $this->instance->releaseAll();
+
+ $this->assertFalse($this->instance->isLocked('bar'));
+ $this->assertFalse($this->instance->isLocked('#/$%§'));
+ }
+}
\ No newline at end of file
--- /dev/null
+<?php
+
+namespace Friendica\Test\src\Core\Lock;
+
+
+use Friendica\Core\Lock\SemaphoreLockDriver;
+
+class SemaphoreLockDriverTest extends LockTest
+{
+ protected function getInstance()
+ {
+ return new SemaphoreLockDriver();
+ }
+}
\ No newline at end of file
projects / friendica.git / commitdiff