WebSVN – Moodle – Diff – /cache/classes/helper.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/>.
-/**
- * Cache helper class
- *
- * This file is part of Moodle's cache API, affectionately called MUC.
- * It contains the components that are requried in order to use caching.
- *
- * @package    core
- * @category   cache
- * @copyright  2012 Sam Hemelryk
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+namespace core_cache;
- */
+use core\lang_string;
 use core\exception\coding_exception;
-defined('MOODLE_INTERNAL') || die();
+use DirectoryIterator;
 /**
  * The cache helper class.
+ *
  * The cache helper class provides common functionality to the cache API and is useful to developers within to interact with
  * the cache API in a general way.
+ *
- * @package    core
+ * @package    core_cache
  * @category   cache
  * @copyright  2012 Sam Hemelryk
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
-class cache_helper {
+ */
 class helper {
     /**
      * Statistics gathered by the cache API during its operation will be used here.
      * @static
      * @var array
      */
-    protected static $stats = array();
+    protected static $stats = [];
     /**
      * The instance of the cache helper.
-     * @var cache_helper
+     * @var self
      * configuration file has been created which allows use to set up caching when ever is required.
+     *
      * @return bool
      */
     public static function ready_for_early_init() {
-        return cache_config::config_file_exists();
+        return config::config_file_exists();
+    }
     /**
-     * Returns an instance of the cache_helper.
+     * Returns an instance of the helper.
+     *
      * This is designed for internal use only and acts as a static store.
      * @staticvar null $instance
-     * @return cache_helper
+     * @return self
      */
     protected static function instance() {
         if (is_null(self::$instance)) {
-            self::$instance = new cache_helper();
+            self::$instance = new self();
+        }
         return self::$instance;
+    }
     /**
-     * Constructs an instance of the cache_helper class. Again for internal use only.
+     * Constructs an instance of the helper class. Again for internal use only.
      */
     protected function __construct() {
         // Nothing to do here, just making sure you can't get an instance of this.
+    }
     /**
      * Used as a data store for initialised definitions.
      * @var array
      */
-    protected $definitions = array();
+    protected $definitions = [];
     /**
      * Used as a data store for initialised cache stores
      * We use this because we want to avoid establishing multiple instances of a single store.
      * @var array
      */
-    protected $stores = array();
+    protected $stores = [];
     /**
      * Returns the class for use as a cache loader for the given mode.
+     *
-     * @param int $mode One of cache_store::MODE_
+     * @param int $mode One of store::MODE_
      * @return string
      * @throws coding_exception
      */
     public static function get_class_for_mode($mode) {
         switch ($mode) {
-            case cache_store::MODE_APPLICATION :
+            case store::MODE_APPLICATION:
-                return 'cache_application';
+                return application_cache::class;
-            case cache_store::MODE_REQUEST :
+            case store::MODE_REQUEST:
-                return 'cache_request';
+                return request_cache::class;
-            case cache_store::MODE_SESSION :
+            case store::MODE_SESSION:
-                return 'cache_session';
+                return session_cache::class;
         }
-        throw new coding_exception('Unknown cache mode passed. Must be one of cache_store::MODE_*');
+        throw new coding_exception('Unknown cache mode passed. Must be one of store::MODE_*');
+    }
     /**
      * Returns the cache stores to be used with the given definition.
-     * @param cache_definition $definition
+     * @param definition $definition
      * @return array
      */
-    public static function get_cache_stores(cache_definition $definition) {
+    public static function get_cache_stores(definition $definition) {
-        $instance = cache_config::instance();
+        $instance = config::instance();
         $stores = $instance->get_stores_for_definition($definition);
         $stores = self::initialise_cachestore_instances($stores, $definition);
         return $stores;
     }
     /**
      * Internal function for initialising an array of stores against a given cache definition.
      *
      * @param array $stores
-     * @param cache_definition $definition
+     * @param definition $definition
-     * @return cache_store[]
+     * @return store[]
      */
-    protected static function initialise_cachestore_instances(array $stores, cache_definition $definition) {
+    protected static function initialise_cachestore_instances(array $stores, definition $definition) {
-        $return = array();
+        $return = [];
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         foreach ($stores as $name => $details) {
             $store = $factory->create_store_from_config($name, $details, $definition);
             if ($store !== false) {
                 $return[] = $store;
             }
         }
         return $return;
     }
     /**
-     * Returns a cache_lock instance suitable for use with the store.
+     * Returns a locakable_cache_interface instance suitable for use with the store.
+     *
-     * @param cache_store $store
+     * @param store $store
-     * @return cache_lock_interface
+     * @return lockable_cache_interface
      */
+     *
      * @return array
      */
     public static function early_get_cache_plugins() {
         global $CFG;
-        $result = array();
+        $result = [];
-        $ignored = array('CVS', '_vti_cnf', 'simpletest', 'db', 'yui', 'tests');
+        $ignored = ['CVS', '_vti_cnf', 'simpletest', 'db', 'yui', 'tests'];
-        $fulldir = $CFG->dirroot.'/cache/stores';
+        $fulldir = $CFG->dirroot . '/cache/stores';
         $items = new DirectoryIterator($fulldir);
         foreach ($items as $item) {
             if ($item->isDot() or !$item->isDir()) {
                 continue;
+            }
+            }
             if (!is_valid_plugin_name($pluginname)) {
                 // Better ignore plugins with problematic names here.
                 continue;
+            }
-            $result[$pluginname] = $fulldir.'/'.$pluginname;
+            $result[$pluginname] = $fulldir . '/' . $pluginname;
             unset($item);
+        }
         unset($items);
         return $result;
+    }
      * @param array $identifiers
      * @param array|string|int $keys
      * @return boolean
      * @throws coding_exception
      */
-    public static function invalidate_by_definition($component, $area, array $identifiers = array(), $keys = array()) {
+    public static function invalidate_by_definition($component, $area, array $identifiers = [], $keys = []) {
         $cache = cache::make($component, $area, $identifiers);
         if (is_array($keys)) {
             $cache->delete_many($keys);
         } else if (is_scalar($keys)) {
             $cache->delete($keys);
         } else {
-            throw new coding_exception('cache_helper::invalidate_by_definition only accepts $keys as array, or scalar.');
+            throw new coding_exception('helper::invalidate_by_definition only accepts $keys as array, or scalar.');
+        }
         return true;
+    }
+     *
      * @param string $event
      * @param array $keys
      */
     public static function invalidate_by_event($event, array $keys) {
-        $instance = cache_config::instance();
+        $instance = config::instance();
         $invalidationeventset = false;
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $inuse = $factory->get_caches_in_use();
         $purgetoken = null;
         foreach ($instance->get_definitions() as $name => $definitionarr) {
-            $definition = cache_definition::load($name, $definitionarr);
+            $definition = definition::load($name, $definitionarr);
             if ($definition->invalidates_on_event($event)) {
                 // First up check if there is a cache loader for this definition already.
                 // If there is we need to invalidate the keys from there.
-                $definitionkey = $definition->get_component().'/'.$definition->get_area();
+                $definitionkey = $definition->get_component() . '/' . $definition->get_area();
                 if (isset($inuse[$definitionkey])) {
                     $inuse[$definitionkey]->delete_many($keys);
+                }
                 // We should only log events for application and session caches.
                 // Request caches shouldn't have events as all data is lost at the end of the request.
                 // Events should only be logged once of course and likely several definitions are watching so we
                 // track its logging with $invalidationeventset.
-                $logevent = ($invalidationeventset === false && $definition->get_mode() !== cache_store::MODE_REQUEST);
+                $logevent = ($invalidationeventset === false && $definition->get_mode() !== store::MODE_REQUEST);
                 if ($logevent) {
                     // Get the event invalidation cache.
                     $cache = cache::make('core', 'eventinvalidation');
                     // Get any existing invalidated keys for this cache.
                     $data = $cache->get($event);
                     if ($data === false) {
                         // There are none.
-                        $data = array();
+                        $data = [];
+                    }
                     // Add our keys to them with the current cache timestamp.
                     if (null === $purgetoken) {
      * @param string $component
      * @param string $area
      * @param array $identifiers
      * @return bool
      */
-    public static function purge_by_definition($component, $area, array $identifiers = array()) {
+    public static function purge_by_definition($component, $area, array $identifiers = []) {
         // Create the cache.
         $cache = cache::make($component, $area, $identifiers);
         // Initialise, in case of a store.
-        if ($cache instanceof cache_store) {
+        if ($cache instanceof store) {
-            $factory = cache_factory::instance();
+            $factory = factory::instance();
             $definition = $factory->create_definition($component, $area, null);
             $cacheddefinition = clone $definition;
             $cacheddefinition->set_identifiers($identifiers);
             $cache->initialise($cacheddefinition);
+        }
      * are only supported on caches without identifiers.
+     *
      * @param string $event
      */
     public static function purge_by_event($event) {
-        $instance = cache_config::instance();
+        $instance = config::instance();
         $invalidationeventset = false;
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $inuse = $factory->get_caches_in_use();
         $purgetoken = null;
         foreach ($instance->get_definitions() as $name => $definitionarr) {
-            $definition = cache_definition::load($name, $definitionarr);
+            $definition = definition::load($name, $definitionarr);
             if ($definition->invalidates_on_event($event)) {
                 // First up check if there is a cache loader for this definition already.
                 // If there is we need to invalidate the keys from there.
-                $definitionkey = $definition->get_component().'/'.$definition->get_area();
+                $definitionkey = $definition->get_component() . '/' . $definition->get_area();
                 if (isset($inuse[$definitionkey])) {
                     $inuse[$definitionkey]->purge();
                 } else {
                     cache::make($definition->get_component(), $definition->get_area())->purge();
+                }
                 // We should only log events for application and session caches.
                 // Request caches shouldn't have events as all data is lost at the end of the request.
                 // Events should only be logged once of course and likely several definitions are watching so we
                 // track its logging with $invalidationeventset.
-                $logevent = ($invalidationeventset === false && $definition->get_mode() !== cache_store::MODE_REQUEST);
+                $logevent = ($invalidationeventset === false && $definition->get_mode() !== store::MODE_REQUEST);
                 // We need to flag the event in the "Event invalidation" cache if it hasn't already happened.
                 if ($logevent && $invalidationeventset === false) {
                     // Get the event invalidation cache.
                     $cache = cache::make('core', 'eventinvalidation');
                     // Create a key to invalidate all.
                     if (null === $purgetoken) {
                         $purgetoken = cache::get_purge_token(true);
+                    }
-                    $data = array(
+                    $data = [
                         'purged' => $purgetoken,
-                    );
+                    ];
                     // Set that data back to the cache.
                     $cache->set($event, $data);
                     // This only needs to occur once.
     /**
      * Ensure that the stats array is ready to collect information for the given store and definition.
      * @param string $store
      * @param string $storeclass
      * @param string $definition A string that identifies the definition.
-     * @param int $mode One of cache_store::MODE_*. Since 2.9.
+     * @param int $mode One of store::MODE_*. Since 2.9.
      */
-    protected static function ensure_ready_for_stats($store, $storeclass, $definition, $mode = cache_store::MODE_APPLICATION) {
+    protected static function ensure_ready_for_stats($store, $storeclass, $definition, $mode = store::MODE_APPLICATION) {
         // This function is performance-sensitive, so exit as quickly as possible
         // if we do not need to do anything.
         if (isset(self::$stats[$definition]['stores'][$store])) {
             return;
+        }
         if (!array_key_exists($definition, self::$stats)) {
-            self::$stats[$definition] = array(
+            self::$stats[$definition] = [
                 'mode' => $mode,
-                'stores' => array(
+                'stores' => [
-                    $store => array(
+                    $store => [
                         'class' => $storeclass,
                         'hits' => 0,
                         'misses' => 0,
                         'sets' => 0,
-                        'iobytes' => cache_store::IO_BYTES_NOT_SUPPORTED,
+                        'iobytes' => store::IO_BYTES_NOT_SUPPORTED,
                         'locks' => 0,
-                    )
+                    ],
-                )
+                ],
-            );
+            ];
         } else if (!array_key_exists($store, self::$stats[$definition]['stores'])) {
-            self::$stats[$definition]['stores'][$store] = array(
+            self::$stats[$definition]['stores'][$store] = [
                 'class' => $storeclass,
                 'hits' => 0,
                 'misses' => 0,
                 'sets' => 0,
-                'iobytes' => cache_store::IO_BYTES_NOT_SUPPORTED,
+                'iobytes' => store::IO_BYTES_NOT_SUPPORTED,
                 'locks' => 0,
-            );
+            ];
+        }
+    }
     /**
      * Returns a string to describe the definition.
+     *
      * This method supports the definition as a string due to legacy requirements.
      * It is backwards compatible when a string is passed but is not accurate.
      *
      * @since 2.9
-     * @param cache_definition|string $definition
+     * @param definition|string $definition
      * @return string
      */
     protected static function get_definition_stat_id_and_mode($definition) {
-        if (!($definition instanceof cache_definition)) {
+        if (!($definition instanceof definition)) {
             // All core calls to this method have been updated, this is the legacy state.
             // We'll use application as the default as that is the most common, really this is not accurate of course but
             // at this point we can only guess and as it only affects calls to cache stat outside of core (of which there should
             // be none) I think that is fine.
             debugging('Please update you cache stat calls to pass the definition rather than just its ID.', DEBUG_DEVELOPER);
-            return array((string)$definition, cache_store::MODE_APPLICATION);
+            return [(string)$definition, store::MODE_APPLICATION];
+        }
-        return array($definition->get_id(), $definition->get_mode());
+        return [$definition->get_id(), $definition->get_mode()];
+    }
     /**
      * Record a cache hit in the stats for the given store and definition.
+     *
      * In Moodle 2.9 the $definition argument changed from accepting only a string to accepting a string or a
-     * cache_definition instance. It is preferable to pass a cache definition instance.
+     * definition instance. It is preferable to pass a cache definition instance.
+     *
-     * In Moodle 3.9 the first argument changed to also accept a cache_store.
+     * In Moodle 3.9 the first argument changed to also accept a store.
      *
      * @internal
-     * @param string|cache_store $store
+     * @param string|store $store
-     * @param cache_definition $definition You used to be able to pass a string here, however that is deprecated please pass the
+     * @param definition $definition You used to be able to pass a string here, however that is deprecated please pass the
-     *      actual cache_definition object now.
+     *      actual definition object now.
+     * @param int $hits The number of hits to record (by default 1)
+     * @param int $readbytes Number of bytes read from the cache or store::IO_BYTES_NOT_SUPPORTED
+     */
+    public static function record_cache_hit(
-     * @param int $hits The number of hits to record (by default 1)
+        $store,
+        $definition,
-     * @param int $readbytes Number of bytes read from the cache or cache_store::IO_BYTES_NOT_SUPPORTED
+        int $hits = 1,
-     */
+        int $readbytes = store::IO_BYTES_NOT_SUPPORTED,
-    public static function record_cache_hit($store, $definition, int $hits = 1, int $readbytes = cache_store::IO_BYTES_NOT_SUPPORTED): void {
+    ): void {
         $storeclass = '';
-        if ($store instanceof cache_store) {
+        if ($store instanceof store) {
             $storeclass = get_class($store);
             $store = $store->my_name();
+        }
-        list($definitionstr, $mode) = self::get_definition_stat_id_and_mode($definition);
+        [$definitionstr, $mode] = self::get_definition_stat_id_and_mode($definition);
         self::ensure_ready_for_stats($store, $storeclass, $definitionstr, $mode);
         self::$stats[$definitionstr]['stores'][$store]['hits'] += $hits;
-        if ($readbytes !== cache_store::IO_BYTES_NOT_SUPPORTED) {
+        if ($readbytes !== store::IO_BYTES_NOT_SUPPORTED) {
-            if (self::$stats[$definitionstr]['stores'][$store]['iobytes'] === cache_store::IO_BYTES_NOT_SUPPORTED) {
+            if (self::$stats[$definitionstr]['stores'][$store]['iobytes'] === store::IO_BYTES_NOT_SUPPORTED) {
                 self::$stats[$definitionstr]['stores'][$store]['iobytes'] = $readbytes;
             } else {
     /**
      * Record a cache miss in the stats for the given store and definition.
+     *
      * In Moodle 2.9 the $definition argument changed from accepting only a string to accepting a string or a
-     * cache_definition instance. It is preferable to pass a cache definition instance.
+     * definition instance. It is preferable to pass a cache definition instance.
      *
-     * In Moodle 3.9 the first argument changed to also accept a cache_store.
+     * In Moodle 3.9 the first argument changed to also accept a store.
+     *
      * @internal
-     * @param string|cache_store $store
+     * @param string|store $store
-     * @param cache_definition $definition You used to be able to pass a string here, however that is deprecated please pass the
+     * @param definition $definition You used to be able to pass a string here, however that is deprecated please pass the
-     *      actual cache_definition object now.
+     *      actual definition object now.
      * @param int $misses The number of misses to record (by default 1)
      */
     public static function record_cache_miss($store, $definition, $misses = 1) {
         $storeclass = '';
-        if ($store instanceof cache_store) {
+        if ($store instanceof store) {
             $storeclass = get_class($store);
             $store = $store->my_name();
         }
-        list($definitionstr, $mode) = self::get_definition_stat_id_and_mode($definition);
+        [$definitionstr, $mode] = self::get_definition_stat_id_and_mode($definition);
         self::ensure_ready_for_stats($store, $storeclass, $definitionstr, $mode);
         self::$stats[$definitionstr]['stores'][$store]['misses'] += $misses;
+    }
     /**
      * Record a cache set in the stats for the given store and definition.
      *
      * In Moodle 2.9 the $definition argument changed from accepting only a string to accepting a string or a
-     * cache_definition instance. It is preferable to pass a cache definition instance.
+     * definition instance. It is preferable to pass a cache definition instance.
+     *
-     * In Moodle 3.9 the first argument changed to also accept a cache_store.
+     * In Moodle 3.9 the first argument changed to also accept a store.
      *
      * @internal
-     * @param string|cache_store $store
+     * @param string|store $store
-     * @param cache_definition $definition You used to be able to pass a string here, however that is deprecated please pass the
+     * @param definition $definition You used to be able to pass a string here, however that is deprecated please pass the
-     *      actual cache_definition object now.
+     *      actual definition object now.
      * @param int $sets The number of sets to record (by default 1)
-     * @param int $writebytes Number of bytes written to the cache or cache_store::IO_BYTES_NOT_SUPPORTED
+     * @param int $writebytes Number of bytes written to the cache or store::IO_BYTES_NOT_SUPPORTED
+     */
+    public static function record_cache_set(
+        $store,
-     */
+        $definition,
+        int $sets = 1,
-    public static function record_cache_set($store, $definition, int $sets = 1,
+        int $writebytes = store::IO_BYTES_NOT_SUPPORTED
-            int $writebytes = cache_store::IO_BYTES_NOT_SUPPORTED) {
+    ) {
         $storeclass = '';
-        if ($store instanceof cache_store) {
+        if ($store instanceof store) {
             $storeclass = get_class($store);
             $store = $store->my_name();
+        }
-        list($definitionstr, $mode) = self::get_definition_stat_id_and_mode($definition);
+        [$definitionstr, $mode] = self::get_definition_stat_id_and_mode($definition);
         self::ensure_ready_for_stats($store, $storeclass, $definitionstr, $mode);
         self::$stats[$definitionstr]['stores'][$store]['sets'] += $sets;
-        if ($writebytes !== cache_store::IO_BYTES_NOT_SUPPORTED) {
+        if ($writebytes !== store::IO_BYTES_NOT_SUPPORTED) {
-            if (self::$stats[$definitionstr]['stores'][$store]['iobytes'] === cache_store::IO_BYTES_NOT_SUPPORTED) {
+            if (self::$stats[$definitionstr]['stores'][$store]['iobytes'] === store::IO_BYTES_NOT_SUPPORTED) {
                 self::$stats[$definitionstr]['stores'][$store]['iobytes'] = $writebytes;
             } else {
                 self::$stats[$definitionstr]['stores'][$store]['iobytes'] += $writebytes;
+     *
      * Think twice before calling this method. It will purge **ALL** caches regardless of whether they have been used recently or
      * anything. This will involve full setup of the cache + the purge operation. On a site using caching heavily this WILL be
      * painful.
+     *
-     * @param bool $usewriter If set to true the cache_config_writer class is used. This class is special as it avoids
+     * @param bool $usewriter If set to true the config_writer class is used. This class is special as it avoids
      *      it is still usable when caches have been disabled.
      *      Please use this option only if you really must. It's purpose is to allow the cache to be purged when it would be
      *      otherwise impossible.
      */
     public static function purge_all($usewriter = false) {
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $config = $factory->create_config_instance($usewriter);
         foreach ($config->get_all_stores() as $store) {
             self::purge_store($store['name'], $config);
+        }
         foreach ($factory->get_adhoc_caches_in_use() as $cache) {
     /**
      * Purges a store given its name.
+     *
      * @param string $storename
-     * @param cache_config $config
+     * @param config|null $config
      * @return bool
      */
-    public static function purge_store($storename, cache_config $config = null) {
+    public static function purge_store($storename, ?config $config = null) {
         if ($config === null) {
-            $config = cache_config::instance();
+            $config = config::instance();
+        }
         $stores = $config->get_all_stores();
         // We check are_requirements_met although we expect is_ready is going to check as well.
         if (!$class::are_requirements_met()) {
             return false;
+        }
         // Found the store: is it ready?
-        /* @var cache_store $instance */
+        /* @var store $instance */
         $instance = new $class($store['name'], $store['configuration']);
         if (!$instance->is_ready()) {
             unset($instance);
             return false;
+        }
         foreach ($config->get_definitions_by_store($storename) as $id => $definition) {
-            $definition = cache_definition::load($id, $definition);
+            $definition = definition::load($id, $definition);
             $definitioninstance = clone($instance);
             $definitioninstance->initialise($definition);
             $definitioninstance->purge();
             unset($definitioninstance);
+        }
+    }
     /**
      * Purges all of the stores used by a definition.
      *
-     * Unlike cache_helper::purge_by_definition this purges all of the data from the stores not
+     * Unlike helper::purge_by_definition this purges all of the data from the stores not
      * just the data relating to the definition.
      * This function is useful when you must purge a definition that requires setup but you don't
      * want to set it up.
+     *
      * @param string $component
      * @param string $area
      */
     public static function purge_stores_used_by_definition($component, $area) {
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $config = $factory->create_config_instance();
         $definition = $factory->create_definition($component, $area);
         $stores = $config->get_stores_for_definition($definition);
         foreach ($stores as $store) {
+    }
     /**
      * Returns the translated name of the definition.
      *
-     * @param cache_definition $definition
+     * @param definition $definition
      * @return lang_string
      */
     public static function get_definition_name($definition) {
-        if ($definition instanceof cache_definition) {
+        if ($definition instanceof definition) {
             return $definition->get_name();
         }
-        $identifier = 'cachedef_'.clean_param($definition['area'], PARAM_STRINGID);
+        $identifier = 'cachedef_' . clean_param($definition['area'], PARAM_STRINGID);
         $component = $definition['component'];
         if ($component === 'core') {
             $component = 'cache';
+        }
         return new lang_string($identifier, $component);
+    }
     /**
      * Hashes a descriptive key to make it shorter and still unique.
      * @param string|int $key
-     * @param cache_definition $definition
+     * @param definition $definition
      * @return string
      */
-    public static function hash_key($key, cache_definition $definition) {
+    public static function hash_key($key, definition $definition) {
+        if ($definition->uses_simple_keys()) {
-        if ($definition->uses_simple_keys()) {
+            if (debugging() && preg_match('#[^a-zA-Z0-9_]#', $key ?? '')) {
+                throw new coding_exception(
+                    'Cache definition ' . $definition->get_id() . ' requires simple keys. Invalid key provided.',
-            if (debugging() && preg_match('#[^a-zA-Z0-9_]#', $key ?? '')) {
+                    $key,
-                throw new coding_exception('Cache definition '.$definition->get_id().' requires simple keys. Invalid key provided.', $key);
+                );
+            }
             // We put the key first so that we can be sure the start of the key changes.
             return (string)$key . '-' . $definition->generate_single_key_prefix();
      * Finds all definitions and updates them within the cache config file.
+     *
      * @param bool $coreonly If set to true only core definitions will be updated.
      */
     public static function update_definitions($coreonly = false) {
-        global $CFG;
-        // Include locallib.
-        require_once($CFG->dirroot.'/cache/locallib.php');
         // First update definitions
-        cache_config_writer::update_definitions($coreonly);
+        config_writer::update_definitions($coreonly);
         // Second reset anything we have already initialised to ensure we're all up to date.
-        cache_factory::reset();
+        factory::reset();
+    }
     /**
      * Update the site identifier stored by the cache API.
+     *
      * @param string $siteidentifier
      * @return string The new site identifier.
      */
-    public static function update_site_identifier($siteidentifier) {
-        global $CFG;
-        // Include locallib.
-        require_once($CFG->dirroot.'/cache/locallib.php');
+    public static function update_site_identifier($siteidentifier) {
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $factory->updating_started();
         $config = $factory->create_config_instance(true);
         $siteidentifier = $config->update_site_identifier($siteidentifier);
         $factory->updating_finished();
-        cache_factory::reset();
+        factory::reset();
         return $siteidentifier;
+    }
         global $CFG;
         if (!is_null(self::$siteidentifier)) {
             return self::$siteidentifier;
+        }
         // If site identifier hasn't been collected yet attempt to get it from the cache config.
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         // If the factory is initialising then we don't want to try to get it from the config or we risk
         // causing the cache to enter an infinite initialisation loop.
         if (!$factory->is_initialising()) {
             $config = $factory->create_config_instance();
             self::$siteidentifier = $config->get_site_identifier();
     public static function clean_old_session_data($output = false) {
         global $CFG;
         if ($output) {
             mtrace('Cleaning up stale session data from cache stores.');
+        }
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $config = $factory->create_config_instance();
         $definitions = $config->get_definitions();
         $purgetime = time() - $CFG->sessiontimeout;
         foreach ($definitions as $definitionarray) {
             // We are only interested in session caches.
-            if (!($definitionarray['mode'] & cache_store::MODE_SESSION)) {
+            if (!($definitionarray['mode'] & store::MODE_SESSION)) {
                 continue;
+            }
             $definition = $factory->create_definition($definitionarray['component'], $definitionarray['area']);
             $stores = $config->get_stores_for_definition($definition);
             // Turn them into store instances.
             $stores = self::initialise_cachestore_instances($stores, $definition);
             // Initialise all of the stores used for that definition.
             foreach ($stores as $store) {
                 // If the store doesn't support searching we can skip it.
-                if (!($store instanceof cache_is_searchable)) {
+                if (!($store instanceof searchable_cache_interface)) {
                     debugging('Cache stores used for session definitions should ideally be searchable.', DEBUG_DEVELOPER);
                     continue;
+                }
                 // Get all of the last access keys.
-                $keys = $store->find_by_prefix(cache_session::LASTACCESS);
+                $keys = $store->find_by_prefix(session_cache::LASTACCESS);
                 $todelete = [];
                 foreach ($store->get_many($keys) as $key => $value) {
                     $expiresvalue = 0;
-                    if ($value instanceof cache_ttl_wrapper) {
+                    if ($value instanceof ttl_wrapper) {
                         $expiresvalue = $value->data;
-                    } else if ($value instanceof cache_cached_object) {
+                    } else if ($value instanceof cached_object) {
                         $expiresvalue = $value->restore_object();
                     } else {
                         $expiresvalue = $value;
+                    }
                     $expires = (int) $expiresvalue;
                     if ($expires > 0 && $expires < $purgetime) {
-                        $prefix = substr($key, strlen(cache_session::LASTACCESS));
+                        $prefix = substr($key, strlen(session_cache::LASTACCESS));
                         $foundbyprefix = $store->find_by_prefix($prefix);
                         $todelete = array_merge($todelete, [$key], $foundbyprefix);
+                    }
+                }
                 if ($todelete) {
-                    $outcome = (int)$store->delete_many($todelete);
+                    $outcome = (int) $store->delete_many($todelete);
                     if ($output) {
                         $strdef = s($definition->get_id());
                         $strstore = s($store->my_name());
                         mtrace("- Removed {$outcome} old {$strdef} sessions from the '{$strstore}' cache store.");
      * These stores would be 100% suitable to map as defaults for cache modes.
+     *
      * @return array[] An array of stores, keys are the store names.
      */
     public static function get_stores_suitable_for_mode_default() {
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
         $config = $factory->create_config_instance();
         $requirements = 0;
         foreach ($config->get_definitions() as $definition) {
-            $definition = cache_definition::load($definition['component'].'/'.$definition['area'], $definition);
+            $definition = definition::load($definition['component'] . '/' . $definition['area'], $definition);
             $requirements = $requirements | $definition->get_requirements_bin();
+        }
-        $stores = array();
+        $stores = [];
         foreach ($config->get_all_stores() as $name => $store) {
             if (!empty($store['features']) && ($store['features'] & $requirements)) {
                 $stores[$name] = $store;
+            }
+        }
+    }
     /**
      * Returns stores suitable for use with a given definition.
      *
-     * @param cache_definition $definition
+     * @param definition $definition
-     * @return cache_store[]
+     * @return store[]
      */
-    public static function get_stores_suitable_for_definition(cache_definition $definition) {
+    public static function get_stores_suitable_for_definition(definition $definition) {
-        $factory = cache_factory::instance();
+        $factory = factory::instance();
-        $stores = array();
+        $stores = [];
         if ($factory->is_initialising() || $factory->stores_disabled()) {
             // No suitable stores here.
             return $stores;
         } else {
      * These get shown on the admin notifications page for example.
+     *
      * @param array|null $stores An array of stores to get warnings for, or null for all.
      * @return string[]
      */
-    public static function warnings(array $stores = null) {
+    public static function warnings(?array $stores = null) {
-        global $CFG;
         if ($stores === null) {
-            require_once($CFG->dirroot.'/cache/locallib.php');
-            $stores = core_cache\administration_helper::get_store_instance_summaries();
+            $stores = administration_helper::get_store_instance_summaries();
+        }
-        $warnings = array();
+        $warnings = [];
         foreach ($stores as $store) {
             if (!empty($store['warnings'])) {
                 $warnings = array_merge($warnings, $store['warnings']);
+            }
+        }
      */
     public static function is_cluster_available(): bool {
         return class_exists('RedisCluster');
+    }
+}
+// Alias this class to the old name.
+// This file will be autoloaded by the legacyclasses autoload system.
+// In future all uses of this class will be corrected and the legacy references will be removed.
+class_alias(helper::class, \cache_helper::class);

Proyectos de Subversion Moodle

(root)/cache/classes/helper.php – Rev 11 → 1441