Adding multihost - locking

Adding Unit-Tests for it

src/Core/Cache/ArrayCache.php

@@ -0,0 +1,83 @@
+<?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;
+		}
+	}
+}

src/Core/Cache/DatabaseCacheDriver.php

@@ -33,11 +33,11 @@ class DatabaseCacheDriver implements ICacheDriver
 		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()
 		];
 

src/Core/Cache/ICacheDriver.php

@@ -12,7 +12,7 @@ use Friendica\Core\Cache;
 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
 	 *
@@ -21,28 +21,27 @@ interface ICacheDriver
 	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
 	 */

src/Core/Cache/IMemoryCacheDriver.php

@@ -0,0 +1,45 @@
+<?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);
+}

src/Core/Cache/MemcacheCacheDriver.php

@@ -10,10 +10,13 @@ use Friendica\Core\Cache;
  *
  * @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;
 
@@ -30,6 +33,9 @@ class MemcacheCacheDriver extends BaseObject implements ICacheDriver
 		}
 	}
 
+	/**
+	 * (@inheritdoc)
+	 */
 	public function get($key)
 	{
 		$return = null;
@@ -54,17 +60,31 @@ class MemcacheCacheDriver extends BaseObject implements ICacheDriver
 		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);
@@ -72,6 +92,14 @@ class MemcacheCacheDriver extends BaseObject implements ICacheDriver
 
 	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);
 	}
 }

src/Core/Cache/MemcachedCacheDriver.php

@@ -10,8 +10,11 @@ use Friendica\Core\Cache;
  *
  * @author Hypolite Petovan <mrpetovan@gmail.com>
  */
-class MemcachedCacheDriver extends BaseObject implements ICacheDriver
+class MemcachedCacheDriver extends BaseObject implements IMemoryCacheDriver
 {
+	use TraitCompareSet;
+	use TraitCompareDelete;
+
 	/**
 	 * @var Memcached
 	 */
@@ -46,14 +49,22 @@ class MemcachedCacheDriver extends BaseObject implements ICacheDriver
 		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)
@@ -67,4 +78,17 @@ class MemcachedCacheDriver extends BaseObject implements ICacheDriver
 	{
 		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);
+	}
 }

src/Core/Cache/RedisCacheDriver.php

@@ -11,7 +11,7 @@ use Friendica\Core\Cache;
  * @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
@@ -55,14 +55,21 @@ class RedisCacheDriver extends BaseObject implements ICacheDriver
 		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)
@@ -74,4 +81,75 @@ class RedisCacheDriver extends BaseObject implements ICacheDriver
 	{
 		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;
+	}
 }

src/Core/Cache/TraitCompareDelete.php

@@ -0,0 +1,45 @@
+<?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;
+		}
+	}
+}

src/Core/Cache/TraitCompareSet.php

@@ -0,0 +1,48 @@
+<?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;
+		}
+	}
+}

src/Core/Lock.php

@@ -10,6 +10,7 @@ namespace Friendica\Core;
  */
 
 use Friendica\Core\Cache\CacheDriverFactory;
+use Friendica\Core\Cache\IMemoryCacheDriver;
 
 /**
  * @brief This class contain Functions for preventing parallel execution of functions
@@ -29,17 +30,23 @@ class Lock
 			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':
@@ -85,7 +92,9 @@ class Lock
 		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());

src/Core/Lock/AbstractLockDriver.php

@@ -1,6 +1,7 @@
 <?php
 
 namespace Friendica\Core\Lock;
+use Friendica\BaseObject;
 
 /**
  * Class AbstractLockDriver
@@ -9,7 +10,7 @@ namespace Friendica\Core\Lock;
  *
  * @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
@@ -23,7 +24,7 @@ abstract class AbstractLockDriver implements ILockDriver
 	 * @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;
 	}
 
 	/**
@@ -50,7 +51,7 @@ abstract class AbstractLockDriver implements ILockDriver
 	 * @return void
 	 */
 	public function releaseAll() {
-		foreach ($this->acquiredLocks as $acquiredLock) {
+		foreach ($this->acquiredLocks as $acquiredLock => $hasLock) {
 			$this->releaseLock($acquiredLock);
 		}
 	}

src/Core/Lock/CacheLockDriver.php

@@ -2,7 +2,7 @@
 
 namespace Friendica\Core\Lock;
 
-use Friendica\Core\Cache\ICacheDriver;
+use Friendica\Core\Cache\IMemoryCacheDriver;
 
 class CacheLockDriver extends AbstractLockDriver
 {
@@ -14,9 +14,9 @@ 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;
 	}
@@ -35,32 +35,31 @@ class CacheLockDriver extends AbstractLockDriver
 		$got_lock = false;
 		$start = time();
 
-		$cachekey = get_app()->get_hostname() . ";lock:" . $key;
+		$cachekey = self::getCacheKey($key);
 
 		do {
 			$lock = $this->cache->get($cachekey);
-
-			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;
-				}
-			}
-			if (is_bool($lock)) {
-				$this->cache->set($cachekey, getmypid(), 300);
+			// When we do want to lock something that was already locked by us.
+			if ((int)$lock == getmypid()) {
 				$got_lock = true;
 			}
 
+			// 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 (!$got_lock && ($timeout > 0)) {
 				usleep(rand(10000, 200000));
 			}
 		} while (!$got_lock && ((time() - $start) < $timeout));
 
-		$this->markAcquire($key);
-
 		return $got_lock;
 	}
 
@@ -68,22 +67,33 @@ class CacheLockDriver extends AbstractLockDriver
 	 * @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;
 	}
 }

src/Core/Lock/DatabaseLockDriver.php

@@ -4,6 +4,7 @@ namespace Friendica\Core\Lock;
 
 use dba;
 use Friendica\Database\DBM;
+use Friendica\Util\DateTimeFormat;
 
 /**
  * Locking driver that stores the locks in the database
@@ -11,12 +12,7 @@ use Friendica\Database\DBM;
 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)
 	{
@@ -25,26 +21,25 @@ class DatabaseLockDriver extends AbstractLockDriver
 
 		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();
@@ -54,36 +49,42 @@ class DatabaseLockDriver extends AbstractLockDriver
 			}
 		} 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;
+		}
+	}
 }

src/Core/Lock/ILockDriver.php

@@ -9,6 +9,14 @@ namespace Friendica\Core\Lock;
  */
 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

src/Core/Lock/SemaphoreLockDriver.php

@@ -4,6 +4,8 @@ namespace Friendica\Core\Lock;
 
 class SemaphoreLockDriver extends AbstractLockDriver
 {
+	private static $semaphore = [];
+
 	public function __construct()
 	{
 		if (!function_exists('sem_get')) {
@@ -42,10 +44,15 @@ class SemaphoreLockDriver extends AbstractLockDriver
 	 */
 	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;
 	}
 
 	/**
@@ -57,12 +64,24 @@ class SemaphoreLockDriver extends AbstractLockDriver
 	 */
 	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;
+	}
 }