<?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/>.
namespace core_cache;
use cachestore_static;
use core\exception\coding_exception;
/**
* The cache factory class used when the Cache has been disabled.
*
* @package core_cache
* @copyright 2012 Sam Hemelryk
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class disabled_factory extends factory {
/** @var array Array of temporary caches in use. */
protected static $tempcaches = [];
/**
* Returns an instance of the factory method.
*
* @param bool $forcereload Unused.
* @return factory
* @throws coding_exception
*/
public static function instance($forcereload = false) {
throw new coding_exception('You must not call to this cache factory within your code.');
}
/**
* Creates a definition instance or returns the existing one if it has already been created.
*
* @param string $component
* @param string $area
* @param string $unused Used to be datasourceaggregate but that was removed and this is now unused.
* @return definition
*/
public function create_definition($component, $area, $unused = null) {
$definition = parent::create_definition($component, $area);
if ($definition->has_data_source()) {
return $definition;
}
return definition::load_adhoc(store::MODE_REQUEST, $component, $area);
}
/**
* Common public method to create a cache instance given a definition.
*
* @param definition $definition
* @return application_cache|session_cache|store
* @throws coding_exception
*/
public function create_cache(definition $definition) {
$loader = null;
if ($definition->has_data_source()) {
$loader = $definition->get_data_source();
}
return new disabled_cache($definition, $this->create_dummy_store($definition), $loader);
}
/**
* Creates a cache object given the parameters for a definition.
*
* @param string $component
* @param string $area
* @param array $identifiers
* @param string $unused Used to be datasourceaggregate but that was removed and this is now unused.
* @return application_cache|session_cache|request_cache
*/
public function create_cache_from_definition($component, $area, array $identifiers = [], $unused = null) {
// Temporary in-memory caches are sometimes allowed when caching is disabled.
if (\core_cache\allow_temporary_caches::is_allowed() && !$identifiers) {
$key = $component . '/' . $area;
if (array_key_exists($key, self::$tempcaches)) {
$cache = self::$tempcaches[$key];
} else {
$definition = $this->create_definition($component, $area);
// The cachestore_static class returns true to all three 'SUPPORTS_' checks so it
// can be used with all definitions.
$store = new cachestore_static('TEMP:' . $component . '/' . $area);
$store->initialise($definition);
// We need to use a cache loader wrapper rather than directly returning the store,
// or it wouldn't have support for versioning. The application_cache class is used
// (rather than request_cache which might make more sense logically) because it
// includes support for locking, which might be necessary for some caches.
$cache = new application_cache($definition, $store);
self::$tempcaches[$key] = $cache;
}
return $cache;
}
// Regular cache definitions are cached inside create_definition(). This is not the case for disabledlib.php
// definitions as they use load_adhoc(). They are built as a new object on each call.
// We do not need to clone the definition because we know it's new.
$definition = $this->create_definition($component, $area);
$definition->set_identifiers($identifiers);
$cache = $this->create_cache($definition);
return $cache;
}
/**
* Removes all temporary caches.
*
* Don't call this directly - used by {@see \core_cache\allow_temporary_caches}.
*/
public static function clear_temporary_caches(): void {
self::$tempcaches = [];
}
/**
* Creates an ad-hoc cache from the given param.
*
* @param int $mode
* @param string $component
* @param string $area
* @param array $identifiers
* @param array $options An array of options, available options are:
* - simplekeys : Set to true if the keys you will use are a-zA-Z0-9_
* - simpledata : Set to true if the type of the data you are going to store is scalar, or an array of scalar vars
* - staticacceleration : If set to true the cache will hold onto all data passing through it.
* - staticaccelerationsize : Sets the max size of the static acceleration array.
* @return application_cache|session_cache|request_cache
*/
public function create_cache_from_params($mode, $component, $area, array $identifiers = [], array $options = []) {
// Regular cache definitions are cached inside create_definition(). This is not the case for disabledlib.php
// definitions as they use load_adhoc(). They are built as a new object on each call.
// We do not need to clone the definition because we know it's new.
$definition = definition::load_adhoc($mode, $component, $area, $options);
$definition->set_identifiers($identifiers);
$cache = $this->create_cache($definition);
return $cache;
}
/**
* Creates a store instance given its name and configuration.
*
* @param string $name Unused.
* @param array $details Unused.
* @param definition $definition
* @return boolean|store
*/
public function create_store_from_config($name, array $details, definition $definition) {
return $this->create_dummy_store($definition);
}
/**
* Creates a cache config instance with the ability to write if required.
*
* @param bool $writer Unused.
* @return disabled_config|config_writer
*/
public function create_config_instance($writer = false) {
// We are always going to use the disabled_config class for all regular request.
// However if the code has requested the writer then likely something is changing and
// we're going to need to interact with the config.php file.
// In this case we will still use the config_writer.
$class = disabled_config::class;
if ($writer) {
// If the writer was requested then something is changing.
$class = config_writer::class;
}
if (!array_key_exists($class, $this->configs)) {
self::set_state(factory::STATE_INITIALISING);
if ($class === disabled_config::class) {
$configuration = $class::create_default_configuration();
$this->configs[$class] = new $class();
} else {
$configuration = false;
// If we need a writer, we should get the classname from the generic factory.
// This is so alternative classes can be used if a different writer is required.
$this->configs[$class] = parent::get_disabled_writer();
}
$this->configs[$class]->load($configuration);
}
self::set_state(factory::STATE_READY);
// Return the instance.
return $this->configs[$class];
}
/**
* Returns true if the cache API has been disabled.
*
* @return bool
*/
public function is_disabled() {
return true;
}
}
// 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(disabled_factory::class, \cache_factory_disabled::class);