WebSVN – Moodle – Diff – /cache/stores/redis/lib.php

 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
-/**
- * Redis Cache Store - Main library
+use core_cache\configurable_cache_interface;
- *
+use core_cache\definition;
- * @package   cachestore_redis
+use core_cache\key_aware_cache_interface;
- * @copyright 2013 Adam Durana
+use core_cache\lockable_cache_interface;
+use core_cache\searchable_cache_interface;
- * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+use core_cache\store;
- */
+use core\clock;
-defined('MOODLE_INTERNAL') || die();
+use core\di;
 /**
  * Redis Cache Store
+ *
  * To allow separation of definitions in Moodle and faster purging, each cache
  * is implemented as a Redis hash.  That is a trade-off between having functionality of TTL
  * and being able to manage many caches in a single redis instance.  Given the recommendation
  * not to use TTL if at all possible and the benefits of having many stores in Redis using the
+ * hash configuration, the hash implementation has been used.
  * hash configuration, the hash implementation has been used.
  * @package   cachestore_redis
  * @copyright   2013 Adam Durana
  * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
- */
+class cachestore_redis extends store implements
+    key_aware_cache_interface,
+    configurable_cache_interface,
+    searchable_cache_interface,
-class cachestore_redis extends cache_store implements cache_is_key_aware, cache_is_lockable,
+    lockable_cache_interface
         cache_is_configurable, cache_is_searchable {
     /**
      * Compressor: none.
     /**
      * @var int Number of items to delete from cache in one batch when expiring old TTL data.
      */
     const TTL_EXPIRE_BATCH = 10000;
+    /** @var int The number of seconds to wait for a connection or response from the Redis server. */
+    const CONNECTION_TIMEOUT = 3;
     /**
      * Name of this store.
+     *
      * @var string
     protected $isready = false;
     /**
      * Cache definition for this store.
      *
-     * @var cache_definition
+     * @var definition
      */
     protected $definition = null;
+     *
      * @var int
      */
     protected $compressor = self::COMPRESSOR_NONE;
+    /**
+     * The number of seconds to wait for a connection or response from the Redis server.
+     *
+     * @var int
+     */
+    protected $connectiontimeout = self::CONNECTION_TIMEOUT;
     /**
      * Bytes read or written by last call to set()/get() or set_many()/get_many().
+     *
      * @var int
     protected $locktimeout = 600;
     /** @var ?array Array of current locks, or null if we haven't registered shutdown function */
+    protected $currentlocks = null;
+    /** @var clock */
-    protected $currentlocks = null;
+    private readonly clock $clock;
     /**
      * Determines if the requirements for this type of store are met.
+     *
             $this->serializer = (int)$configuration['serializer'];
+        }
         if (array_key_exists('compressor', $configuration)) {
             $this->compressor = (int)$configuration['compressor'];
+        }
+        if (array_key_exists('connectiontimeout', $configuration)) {
+            $this->connectiontimeout = (int)$configuration['connectiontimeout'];
+        }
         if (array_key_exists('lockwait', $configuration)) {
             $this->lockwait = (int)$configuration['lockwait'];
+        }
         if (array_key_exists('locktimeout', $configuration)) {
             $this->locktimeout = (int)$configuration['locktimeout'];
+        }
         $this->redis = $this->new_redis($configuration);
+        $this->clock = di::get(clock::class);
+    }
     /**
      * Create a new Redis or RedisCluster instance and connect to the server.
+        }
         // Connect to redis.
         $redis = null;
         try {
             // Create a $redis object of a RedisCluster or Redis class.
+            $phpredisversion = phpversion('redis');
             if ($clustermode) {
+                if (version_compare($phpredisversion, '6.0.0', '>=')) {
+                    // Named parameters are fully supported starting from version 6.0.0.
+                    $redis = new RedisCluster(
+                        name: null,
+                        seeds: $trimmedservers,
+                        timeout: $this->connectiontimeout, // Timeout.
+                        read_timeout: $this->connectiontimeout, // Read timeout.
+                        persistent: true,
+                        auth: $password,
-                $redis = new RedisCluster(null, $trimmedservers, 1, 1, true, $password, !empty($opts) ? $opts : null);
+                        context: !empty($opts) ? $opts : null,
+                    );
+                } else {
+                    $redis = new RedisCluster(
+                        null,
+                        $trimmedservers,
+                        $this->connectiontimeout,
+                        $this->connectiontimeout,
+                        true, $password,
+                        !empty($opts) ? $opts : null,
+                    );
+                }
             } else {
                 $redis = new Redis();
-                $redis->connect($server, $port, 1, null, 100, 1, $opts);
+                if (version_compare($phpredisversion, '6.0.0', '>=')) {
+                    // Named parameters are fully supported starting from version 6.0.0.
+                    $redis->connect(
+                        host: $server,
+                        port: $port,
+                        timeout: $this->connectiontimeout, // Timeout.
+                        retry_interval: 100, // Retry interval.
+                        read_timeout: $this->connectiontimeout, // Read timeout.
+                        context: $opts,
+                    );
+                } else {
+                    $redis->connect(
+                        $server, $port,
+                        $this->connectiontimeout,
+                        null,
+,
+                        $this->connectiontimeout,
+                        $opts,
+                    );
+                }
                 if (!empty($password)) {
                     $redis->auth($password);
+                }
+            }
+    }
     /**
      * Initialize the store.
      *
-     * @param cache_definition $definition
+     * @param definition $definition
      * @return bool
      */
-    public function initialise(cache_definition $definition) {
+    public function initialise(definition $definition) {
         $this->definition = $definition;
         $this->hash       = $definition->generate_definition_hash();
         return true;
+    }
     /**
      * Determines if the store has a given key.
      *
-     * @see cache_is_key_aware
+     * @see key_aware_cache_interface
      * @param string $key The key to check for.
      * @return bool True if the key exists, false if it does not.
      */
     public function has($key) {
         return !empty($this->redis->hExists($this->hash, $key));
+    }
     /**
      * Determines if the store has any of the keys in a list.
+     *
-     * @see cache_is_key_aware
+     * @see key_aware_cache_interface
      * @param array $keys The keys to check for.
      * @return bool True if any of the keys are found, false none of the keys are found.
      */
+    }
     /**
      * Determines if the store has all of the keys in a list.
      *
-     * @see cache_is_key_aware
+     * @see key_aware_cache_interface
      * @param array $keys The keys to check for.
      * @return bool True if all of the keys are found, false otherwise.
      */
     public function has_all(array $keys) {
+    }
     /**
      * Tries to acquire a lock with a given name.
      *
-     * @see cache_is_lockable
+     * @see lockable_cache_interface
      * @param string $key Name of the lock to acquire.
      * @param string $ownerid Information to identify owner of lock if acquired.
      * @return bool True if the lock was acquired, false if it was not.
      */
     public function acquire_lock($key, $ownerid) {
+        $timelimit = $this->clock->time() + $this->lockwait;
+        $startlocktime = $this->clock->time();
         $timelimit = time() + $this->lockwait;
         do {
+            // Lock already exists, wait 1 second then retry.
+            $haslock = $this->redis->set($key, $ownerid, ['nx', 'ex' => $this->locktimeout]);
-            // If the key doesn't already exist, grab it and return true.
+            if (!$haslock) {
-            if ($this->redis->setnx($key, $ownerid)) {
+                if ($this->clock->time() < $startlocktime + 5) {
-                // Ensure Redis deletes the key after a bit in case something goes wrong.
+                    // We want a random delay to stagger the polling load. Ideally, this delay should be a fraction
-                $this->redis->expire($key, $this->locktimeout);
+                    // of the average response time. If it is too small we will poll too much and if it is too
-                // If we haven't got it already, better register a shutdown function.
+                    // large we will waste time waiting for no reason. 100ms is the default starting point.
+                    $delay = rand(100, 110);
+                } else {
-                if ($this->currentlocks === null) {
+                    // If we don't get a lock within 5 seconds then there must be a very long-lived process holding the lock
-                    core_shutdown_manager::register_function([$this, 'shutdown_release_locks']);
+                    // so throttle back to just polling roughly once a second.
-                    $this->currentlocks = [];
+                    $delay = rand(1000, 1100);
+                }
-                }
-                $this->currentlocks[$key] = $ownerid;
+                usleep($delay * 1000);
-                return true;
+                continue;
+            }
+            // If we haven't got it already, better register a shutdown function.
+            if ($this->currentlocks === null) {
-            }
+                core_shutdown_manager::register_function([$this, 'shutdown_release_locks']);
+                $this->currentlocks = [];
+            }
+            $this->currentlocks[$key] = $ownerid;
-            // Wait 1 second then retry.
-            sleep(1);
+            return true;
+        } while ($this->clock->time() < $timelimit);
         } while (time() < $timelimit);
         return false;
+    }
+    }
     /**
      * Checks a lock with a given name and owner information.
      *
-     * @see cache_is_lockable
+     * @see lockable_cache_interface
      * @param string $key Name of the lock to check.
      * @param string $ownerid Owner information to check existing lock against.
      * @return mixed True if the lock exists and the owner information matches, null if the lock does not
      *      exist, and false otherwise.
+    }
     /**
      * Releases a given lock if the owner information matches.
      *
-     * @see cache_is_lockable
+     * @see lockable_cache_interface
      * @param string $key Name of the lock to release.
      * @param string $ownerid Owner information to use.
      * @return bool True if the lock is released, false if it is not.
      */
+    }
     /**
      * Creates a configuration array from given 'add instance' form data.
      *
+     * @see configurable_cache_interface
      * @see cache_is_configurable
      * @param stdClass $data
      * @return array
      */
     public static function config_get_configuration_array($data) {
         return array(
             'server' => $data->server,
             'prefix' => $data->prefix,
             'password' => $data->password,
             'serializer' => $data->serializer,
+            'compressor' => $data->compressor,
-            'compressor' => $data->compressor,
+            'connectiontimeout' => $data->connectiontimeout,
             'encryption' => $data->encryption,
             'cafile' => $data->cafile,
             'clustermode' => $data->clustermode,
         );
+    }
     /**
      * Sets form data from a configuration array.
+     *
-     * @see cache_is_configurable
+     * @see configurable_cache_interface
      * @param moodleform $editform
      * @param array $config
      */
             $data['serializer'] = $config['serializer'];
+        }
         if (!empty($config['compressor'])) {
             $data['compressor'] = $config['compressor'];
+        }
+        if (!empty($config['connectiontimeout'])) {
+            $data['connectiontimeout'] = $config['connectiontimeout'];
+        }
         if (!empty($config['encryption'])) {
             $data['encryption'] = $config['encryption'];
+        }
         if (!empty($config['cafile'])) {
             $data['cafile'] = $config['cafile'];
     /**
      * Creates an instance of the store for testing.
+     *
-     * @param cache_definition $definition
+     * @param definition $definition
      * @return mixed An instance of the store, or false if an instance cannot be created.
      */
-    public static function initialise_test_instance(cache_definition $definition) {
+    public static function initialise_test_instance(definition $definition) {
         if (!self::are_requirements_met()) {
             return false;
+        }

Proyectos de Subversion Moodle

(root)/cache/stores/redis/lib.php – Rev 11 → 1441