MDL-48468 cache: Import Redis cachestore

This code was originally taken from; https://github.com/durana/moodle-cachestore_redis
Special thanks to Mark Nielsen and Adam Durana for their work on this.

Since the original import;
- Mode session support has been added.
- Some cleanup of names has been made.
- Data guarantee and references support was added.

cache/stores/redis/README.md

+Redis Cache Store for Moodle
+============================
+
+A Moodle cache store plugin for [Redis](http://redis.io).
+
+This plugin requires the [PhpRedis](https://github.com/nicolasff/phpredis) extension.  The PhpRedis extension can be installed via PECL with `pecl install redis`.

cache/stores/redis/addinstanceform.php

+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// 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 - Add instance form
+ *
+ * @package   cachestore_redis
+ * @copyright 2013 Adam Durana
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+require_once($CFG->dirroot.'/cache/forms.php');
+
+/**
+ * Form for adding instance of Redis Cache Store.
+ *
+ * @copyright   2013 Adam Durana
+ * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class cachestore_redis_addinstance_form extends cachestore_addinstance_form {
+    /**
+     * Builds the form for creating an instance.
+     */
+    protected function configuration_definition() {
+        $form = $this->_form;
+
+        $form->addElement('text', 'server', get_string('server', 'cachestore_redis'), array('size' => 24));
+        $form->setType('server', PARAM_TEXT);
+        $form->addHelpButton('server', 'server', 'cachestore_redis');
+        $form->addRule('server', get_string('required'), 'required');
+
+        $form->addElement('text', 'prefix', get_string('prefix', 'cachestore_redis'), array('size' => 16));
+        $form->setType('prefix', PARAM_TEXT); // We set to text but we have a rule to limit to alphanumext.
+        $form->addHelpButton('prefix', 'prefix', 'cachestore_redis');
+        $form->addRule('prefix', get_string('prefixinvalid', 'cachestore_redis'), 'regex', '#^[a-zA-Z0-9\-_]+$#');
+    }
+}
\ No newline at end of file

cache/stores/redis/lang/en/cachestore_redis.php

+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// 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 - English language strings
+ *
+ * @package   cachestore_redis
+ * @copyright 2013 Adam Durana
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+$string['pluginname'] = 'Redis';
+$string['prefix'] = 'Key prefix';
+$string['prefix_help'] = 'This prefix is used for all key names on the Redis server.
+* If you only have one Moodle instance using this server, you can leave this value default.
+* Due to key length restrictions, a maximum of 5 characters is permitted.';
+$string['prefixinvalid'] = 'Invalid prefix. You can only use a-z A-Z 0-9-_.';
+$string['test_server'] = 'Test Server';
+$string['test_server_desc'] = 'Redis server to use for testing.';
+$string['server'] = 'Server';
+$string['server_help'] = 'This sets the hostname or IP address of the Redis server to use.';
\ No newline at end of file

cache/stores/redis/lib.php

+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// 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
+ *
+ * @package   cachestore_redis
+ * @copyright 2013 Adam Durana
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * 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.
+ *
+ * @copyright   2013 Adam Durana
+ * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class cachestore_redis extends cache_store implements cache_is_key_aware, cache_is_lockable,
+        cache_is_configurable, cache_is_searchable {
+    /**
+     * Name of this store.
+     *
+     * @var string
+     */
+    protected $name;
+
+    /**
+     * The definition hash, used for hash key
+     *
+     * @var string
+     */
+    protected $hash;
+
+    /**
+     * Flag for readiness!
+     *
+     * @var boolean
+     */
+    protected $isready = false;
+
+    /**
+     * Cache definition for this store.
+     *
+     * @var cache_definition
+     */
+    protected $definition = null;
+
+    /**
+     * Connection to Redis for this store.
+     *
+     * @var Redis
+     */
+    protected $redis;
+
+    /**
+     * Determines if the requirements for this type of store are met.
+     *
+     * @return bool
+     */
+    public static function are_requirements_met() {
+        return class_exists('Redis');
+    }
+
+    /**
+     * Determines if this type of store supports a given mode.
+     *
+     * @param int $mode
+     * @return bool
+     */
+    public static function is_supported_mode($mode) {
+        return ($mode === self::MODE_APPLICATION || $mode === self::MODE_SESSION);
+    }
+
+    /**
+     * Get the features of this type of cache store.
+     *
+     * @param array $configuration
+     * @return int
+     */
+    public static function get_supported_features(array $configuration = array()) {
+        return self::SUPPORTS_DATA_GUARANTEE + self::DEREFERENCES_OBJECTS + self::IS_SEARCHABLE;
+    }
+
+    /**
+     * Get the supported modes of this type of cache store.
+     *
+     * @param array $configuration
+     * @return int
+     */
+    public static function get_supported_modes(array $configuration = array()) {
+        return self::MODE_APPLICATION + self::MODE_SESSION;
+    }
+
+    /**
+     * Constructs an instance of this type of store.
+     *
+     * @param string $name
+     * @param array $configuration
+     */
+    public function __construct($name, array $configuration = array()) {
+        $this->name = $name;
+
+        if (!array_key_exists('server', $configuration) || empty($configuration['server'])) {
+            return;
+        }
+        $prefix = !empty($configuration['prefix']) ? $configuration['prefix'] : '';
+        $this->redis = $this->new_redis($configuration['server'], $prefix);
+    }
+
+    /**
+     * Create a new Redis instance and
+     * connect to the server.
+     *
+     * @param string $server The server connection string
+     * @param string $prefix The key prefix
+     * @return Redis
+     */
+    protected function new_redis($server, $prefix = '') {
+        $redis = new Redis();
+        if ($redis->connect($server)) {
+            $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
+            if (!empty($prefix)) {
+                $redis->setOption(Redis::OPT_PREFIX, $prefix);
+            }
+            // Database setting option...
+            $this->isready = $this->ping($redis);
+        } else {
+            $this->isready = false;
+        }
+        return $redis;
+    }
+
+    /**
+     * See if we can ping Redis server
+     *
+     * @param Redis $redis
+     * @return bool
+     */
+    protected function ping(Redis $redis) {
+        try {
+            if ($redis->ping() === false) {
+                return false;
+            }
+        } catch (Exception $e) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Get the name of the store.
+     *
+     * @return string
+     */
+    public function my_name() {
+        return $this->name;
+    }
+
+    /**
+     * Initialize the store.
+     *
+     * @param cache_definition $definition
+     * @return bool
+     */
+    public function initialise(cache_definition $definition) {
+        $this->definition = $definition;
+        $this->hash       = $definition->generate_definition_hash();
+        return true;
+    }
+
+    /**
+     * Determine if the store is initialized.
+     *
+     * @return bool
+     */
+    public function is_initialised() {
+        return ($this->definition !== null);
+    }
+
+    /**
+     * Determine if the store is ready for use.
+     *
+     * @return bool
+     */
+    public function is_ready() {
+        return $this->isready;
+    }
+
+    /**
+     * Get the value associated with a given key.
+     *
+     * @param string $key The key to get the value of.
+     * @return mixed The value of the key, or false if there is no value associated with the key.
+     */
+    public function get($key) {
+        return $this->redis->hGet($this->hash, $key);
+    }
+
+    /**
+     * Get the values associated with a list of keys.
+     *
+     * @param array $keys The keys to get the values of.
+     * @return array An array of the values of the given keys.
+     */
+    public function get_many($keys) {
+        return $this->redis->hMGet($this->hash, $keys);
+    }
+
+    /**
+     * Set the value of a key.
+     *
+     * @param string $key The key to set the value of.
+     * @param mixed $value The value.
+     * @return bool True if the operation succeeded, false otherwise.
+     */
+    public function set($key, $value) {
+        return ($this->redis->hSet($this->hash, $key, $value) !== false);
+    }
+
+    /**
+     * Set the values of many keys.
+     *
+     * @param array $keyvaluearray An array of key/value pairs. Each item in the array is an associative array
+     *      with two keys, 'key' and 'value'.
+     * @return int The number of key/value pairs successfuly set.
+     */
+    public function set_many(array $keyvaluearray) {
+        $pairs = [];
+        foreach ($keyvaluearray as $pair) {
+            $pairs[$pair['key']] = $pair['value'];
+        }
+        if ($this->redis->hMSet($this->hash, $pairs)) {
+            return count($pairs);
+        }
+        return 0;
+    }
+
+    /**
+     * Delete the given key.
+     *
+     * @param string $key The key to delete.
+     * @return bool True if the delete operation succeeds, false otherwise.
+     */
+    public function delete($key) {
+        return ($this->redis->hDel($this->hash, $key) > 0);
+    }
+
+    /**
+     * Delete many keys.
+     *
+     * @param array $keys The keys to delete.
+     * @return int The number of keys successfully deleted.
+     */
+    public function delete_many(array $keys) {
+        // Redis needs the hash as the first argument, so we have to put it at the start of the array.
+        array_unshift($keys, $this->hash);
+        return call_user_func_array(array($this->redis, 'hDel'), $keys);
+    }
+
+    /**
+     * Purges all keys from the store.
+     *
+     * @return bool
+     */
+    public function purge() {
+        return ($this->redis->del($this->hash) !== false);
+    }
+
+    /**
+     * Cleans up after an instance of the store.
+     */
+    public function instance_deleted() {
+        $this->purge();
+        $this->redis->close();
+        unset($this->redis);
+    }
+
+    /**
+     * Determines if the store has a given key.
+     *
+     * @see cache_is_key_aware
+     * @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 $this->redis->hExists($this->hash, $key);
+    }
+
+    /**
+     * Determines if the store has any of the keys in a list.
+     *
+     * @see cache_is_key_aware
+     * @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.
+     */
+    public function has_any(array $keys) {
+        foreach ($keys as $key) {
+            if ($this->has($key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Determines if the store has all of the keys in a list.
+     *
+     * @see cache_is_key_aware
+     * @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) {
+        foreach ($keys as $key) {
+            if (!$this->has($key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Tries to acquire a lock with a given name.
+     *
+     * @see cache_is_lockable
+     * @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) {
+        return $this->redis->setnx($key, $ownerid);
+    }
+
+    /**
+     * Checks a lock with a given name and owner information.
+     *
+     * @see cache_is_lockable
+     * @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.
+     */
+    public function check_lock_state($key, $ownerid) {
+        $result = $this->redis->get($key);
+        if ($result === $ownerid) {
+            return true;
+        }
+        if ($result === false) {
+            return null;
+        }
+        return false;
+    }
+
+    /**
+     * Finds all of the keys being used by this cache store instance.
+     *
+     * @return array of all keys in the hash as a numbered array.
+     */
+    public function find_all() {
+        return $this->redis->hKeys($this->hash);
+    }
+
+    /**
+     * Finds all of the keys whose keys start with the given prefix.
+     *
+     * @param string $prefix
+     *
+     * @return array List of keys that match this prefix.
+     */
+    public function find_by_prefix($prefix) {
+        $return = [];
+        foreach ($this->find_all() as $key) {
+            if (strpos($key, $prefix) === 0) {
+                $return[] = $key;
+            }
+        }
+        return $return;
+    }
+
+    /**
+     * Releases a given lock if the owner information matches.
+     *
+     * @see cache_is_lockable
+     * @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.
+     */
+    public function release_lock($key, $ownerid) {
+        if ($this->check_lock_state($key, $ownerid)) {
+            return ($this->redis->del($key) !== false);
+        }
+        return false;
+    }
+
+    /**
+     * Creates a configuration array from given 'add instance' form data.
+     *
+     * @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);
+    }
+
+    /**
+     * Sets form data from a configuration array.
+     *
+     * @see cache_is_configurable
+     * @param moodleform $editform
+     * @param array $config
+     */
+    public static function config_set_edit_form_data(moodleform $editform, array $config) {
+        $data = array();
+        $data['server'] = $config['server'];
+        $data['prefix'] = !empty($config['prefix']) ? $config['prefix'] : '';
+        $editform->set_data($data);
+    }
+
+
+    /**
+     * Creates an instance of the store for testing.
+     *
+     * @param cache_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) {
+        if (!self::are_requirements_met()) {
+            return false;
+        }
+        $config = get_config('cachestore_redis');
+        if (empty($config->test_server)) {
+            return false;
+        }
+        $cache = new cachestore_redis('Redis test', ['server' => $config->test_server]);
+        $cache->initialise($definition);
+
+        return $cache;
+    }
+
+    /**
+     * Return configuration to use when unit testing.
+     *
+     * @return array
+     */
+    public static function unit_test_configuration() {
+        global $DB;
+
+        if (!self::are_requirements_met() || !self::ready_to_be_used_for_testing()) {
+            throw new moodle_exception('TEST_CACHESTORE_REDIS_TESTSERVERS not configured, unable to create test configuration');
+        }
+
+        return ['server' => TEST_CACHESTORE_REDIS_TESTSERVERS,
+                'prefix' => $DB->get_prefix(),
+        ];
+    }
+
+    /**
+     * Returns true if this cache store instance is both suitable for testing, and ready for testing.
+     *
+     * When TEST_CACHESTORE_REDIS_TESTSERVERS is set, then we are ready to be use d for testing.
+     *
+     * @return bool
+     */
+    public static function ready_to_be_used_for_testing() {
+        return defined('TEST_CACHESTORE_REDIS_TESTSERVERS');
+    }
+}

cache/stores/redis/settings.php

+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// 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 - Settings
+ *
+ * @package   cachestore_redis
+ * @copyright 2013 Adam Durana
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+$settings->add(
+  new admin_setting_configtext(
+    'cachestore_redis/test_server',
+    get_string('test_server', 'cachestore_redis'),
+    get_string('test_server_desc', 'cachestore_redis'),
+    '',
+    PARAM_TEXT,
+    16
+  )
+);

cache/stores/redis/tests/redis_test.php

+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by