Adding multihost - locking

[friendica.git] / src / Core / Lock.php

diff --git a/src/Core/Lock.php b/src/Core/Lock.php
index 9e02d14fcb585dc06418e50b0e51c64300324396..7235c64a982aa3a9e2ec1e6f35f013652655a9ea 100644 (file)
--- a/src/Core/Lock.php
+++ b/src/Core/Lock.php
@@ -1,18 +1,16 @@
 <?php
 /**
- * @file src/Core/Lock.php
+ * @file src/Util/Lock.php
  */
-namespace Friendica\Util;
+namespace Friendica\Core;
 
 /**
  * @file src/Core/Lock.php
  * @brief Functions for preventing parallel execution of functions
  */
 
-use Friendica\Core\Config;
-use Friendica\Core\Lock;
-
-require_once 'include/dba.php';
+use Friendica\Core\Cache\CacheDriverFactory;
+use Friendica\Core\Cache\IMemoryCacheDriver;
 
 /**
  * @brief This class contain Functions for preventing parallel execution of functions
@@ -26,26 +24,85 @@ class Lock
 
        public static function init()
        {
-               switch(Config::get('system', 'lock_driver', 'default')) {
-                       case 'memcache':
-                               self::$driver = new Lock\MemcacheLockDriver();
-                               break;
-                       case 'database':
-                               self::$driver = new Lock\DatabaseLockDriver();
-                               break;
-                       case 'semaphore':
-                               self::$driver = new Lock\SemaphoreLockDriver();
-                               break;
-                       default:
-                               // Determine what's the best/fastest locking driver (default behavior in Friendica)
-                               if (function_exists('sem_get') && version_compare(PHP_VERSION, '5.6.1', '>=')) {
-                                       self::$driver = new Lock\SemaphoreLockDriver();
-                               } elseif (Config::get('system', 'cache_driver', 'database') == 'memcache') {
-                                       self::$driver = new Lock\MemcacheLockDriver();
-                               } else {
+               $lock_driver = Config::get('system', 'lock_driver', 'default');
+
+               try {
+                       switch ($lock_driver) {
+                               case 'memcache':
+                                       $cache_driver = CacheDriverFactory::create('memcache');
+                                       if ($cache_driver instanceof IMemoryCacheDriver) {
+                                               self::$driver = new Lock\CacheLockDriver($cache_driver);
+                                       }
+                                       break;
+
+                               case 'memcached':
+                                       $cache_driver = CacheDriverFactory::create('memcached');
+                                       if ($cache_driver instanceof IMemoryCacheDriver) {
+                                               self::$driver = new Lock\CacheLockDriver($cache_driver);
+                                       }
+                                       break;
+
+                               case 'redis':
+                                       $cache_driver = CacheDriverFactory::create('redis');
+                                       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 ('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 ('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('Using Cache driver for locking failed: ' . $exception->getMessage());
+                       }
                }
+
+               // 3. Use Database Locking as a Fallback
+               self::$driver = new Lock\DatabaseLockDriver();
        }
 
        /**