cache/disabledlib.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * This file contains classes that are used by the Cache API only when it is disabled.
  19  *
  20  * These classes are derivatives of other significant classes used by the Cache API customised specifically
  21  * to only do what is absolutely necessary when initialising and using the Cache API when its been disabled.
  22  *
  23  * @package    core
  24  * @category   cache
  25  * @copyright  2012 Sam Hemelryk
  26  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  27  */
  28
  29 defined('MOODLE_INTERNAL') || die();
  30
  31 /**
  32  * Required as it is needed for cache_config_disabled which extends cache_config_writer.
  33  */
  34 require_once($CFG->dirroot.'/cache/locallib.php');
  35
  36 /**
  37  * The cache loader class used when the Cache has been disabled.
  38  *
  39  * @copyright  2012 Sam Hemelryk
  40  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  41  */
  42 class cache_disabled extends cache {
  43
  44     /**
  45      * Constructs the cache.
  46      *
  47      * @param cache_definition $definition
  48      * @param cache_store $store
  49      * @param null $loader Unused.
  50      */
  51     public function __construct(cache_definition $definition, cache_store $store, $loader = null) {
  52         // Nothing to do here.
  53     }
  54
  55     /**
  56      * Gets a key from the cache.
  57      *
  58      * @param int|string $key
  59      * @param int $strictness Unused.
  60      * @return bool
  61      */
  62     public function get($key, $strictness = IGNORE_MISSING) {
  63         return false;
  64     }
  65
  66     /**
  67      * Gets many keys at once from the cache.
  68      *
  69      * @param array $keys
  70      * @param int $strictness Unused.
  71      * @return array
  72      */
  73     public function get_many(array $keys, $strictness = IGNORE_MISSING) {
  74         $return = array();
  75         foreach ($keys as $key) {
  76             $return[$key] = false;
  77         }
  78         return $return;
  79     }
  80
  81     /**
  82      * Sets a key value pair in the cache.
  83      *
  84      * @param int|string $key Unused.
  85      * @param mixed $data Unused.
  86      * @return bool
  87      */
  88     public function set($key, $data) {
  89         return false;
  90     }
  91
  92     /**
  93      * Sets many key value pairs in the cache at once.
  94      *
  95      * @param array $keyvaluearray Unused.
  96      * @return int
  97      */
  98     public function set_many(array $keyvaluearray) {
  99         return 0;
 100     }
 101
 102     /**
 103      * Deletes an item from the cache.
 104      *
 105      * @param int|string $key Unused.
 106      * @param bool $recurse Unused.
 107      * @return bool
 108      */
 109     public function delete($key, $recurse = true) {
 110         return false;
 111     }
 112
 113     /**
 114      * Deletes many items at once from the cache.
 115      *
 116      * @param array $keys Unused.
 117      * @param bool $recurse Unused.
 118      * @return int
 119      */
 120     public function delete_many(array $keys, $recurse = true) {
 121         return 0;
 122     }
 123
 124     /**
 125      * Checks if the cache has the requested key.
 126      *
 127      * @param int|string $key Unused.
 128      * @return bool
 129      */
 130     public function has($key) {
 131         return false;
 132     }
 133
 134     /**
 135      * Checks if the cache has all of the requested keys.
 136      * @param array $keys Unused.
 137      * @return bool
 138      */
 139     public function has_all(array $keys) {
 140         return false;
 141     }
 142
 143     /**
 144      * Checks if the cache has any of the requested keys.
 145      *
 146      * @param array $keys Unused.
 147      * @return bool
 148      */
 149     public function has_any(array $keys) {
 150         return false;
 151     }
 152
 153     /**
 154      * Purges all items from the cache.
 155      *
 156      * @return bool
 157      */
 158     public function purge() {
 159         return true;
 160     }
 161 }
 162
 163 /**
 164  * The cache factory class used when the Cache has been disabled.
 165  *
 166  * @copyright  2012 Sam Hemelryk
 167  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 168  */
 169 class cache_factory_disabled extends cache_factory {
 170
 171     /**
 172      * Returns an instance of the cache_factor method.
 173      *
 174      * @param bool $forcereload Unused.
 175      * @return cache_factory
 176      * @throws coding_exception
 177      */
 178     public static function instance($forcereload = false) {
 179         throw new coding_exception('You must not call to this cache factory within your code.');
 180     }
 181
 182     /**
 183      * Creates a definition instance or returns the existing one if it has already been created.
 184      *
 185      * @param string $component
 186      * @param string $area
 187      * @param string $unused Used to be datasourceaggregate but that was removed and this is now unused.
 188      * @return cache_definition
 189      */
 190     public function create_definition($component, $area, $unused = null) {
 191         return cache_definition::load_adhoc(cache_store::MODE_REQUEST, $component, $area);
 192     }
 193
 194     /**
 195      * Common public method to create a cache instance given a definition.
 196      *
 197      * @param cache_definition $definition
 198      * @return cache_application|cache_session|cache_store
 199      * @throws coding_exception
 200      */
 201     public function create_cache(cache_definition $definition) {
 202         return new cache_disabled($definition, $this->create_dummy_store($definition));
 203     }
 204
 205     /**
 206      * Creates a cache object given the parameters for a definition.
 207      *
 208      * @param string $component
 209      * @param string $area
 210      * @param array $identifiers
 211      * @param string $unused Used to be datasourceaggregate but that was removed and this is now unused.
 212      * @return cache_application|cache_session|cache_request
 213      */
 214     public function create_cache_from_definition($component, $area, array $identifiers = array(), $unused = null) {
 215         // Regular cache definitions are cached inside create_definition().  This is not the case for disabledlib.php
 216         // definitions as they use load_adhoc().  They are built as a new object on each call.
 217         // We do not need to clone the definition because we know it's new.
 218         $definition = $this->create_definition($component, $area);
 219         $definition->set_identifiers($identifiers);
 220         $cache = $this->create_cache($definition);
 221         return $cache;
 222     }
 223
 224     /**
 225      * Creates an ad-hoc cache from the given param.
 226      *
 227      * @param int $mode
 228      * @param string $component
 229      * @param string $area
 230      * @param array $identifiers
 231      * @param array $options An array of options, available options are:
 232      *   - simplekeys : Set to true if the keys you will use are a-zA-Z0-9_
 233      *   - simpledata : Set to true if the type of the data you are going to store is scalar, or an array of scalar vars
 234      *   - staticacceleration : If set to true the cache will hold onto all data passing through it.
 235      *   - staticaccelerationsize : Sets the max size of the static acceleration array.
 236      * @return cache_application|cache_session|cache_request
 237      */
 238     public function create_cache_from_params($mode, $component, $area, array $identifiers = array(), array $options = array()) {
 239         // Regular cache definitions are cached inside create_definition().  This is not the case for disabledlib.php
 240         // definitions as they use load_adhoc().  They are built as a new object on each call.
 241         // We do not need to clone the definition because we know it's new.
 242         $definition = cache_definition::load_adhoc($mode, $component, $area, $options);
 243         $definition->set_identifiers($identifiers);
 244         $cache = $this->create_cache($definition);
 245         return $cache;
 246     }
 247
 248     /**
 249      * Creates a store instance given its name and configuration.
 250      *
 251      * @param string $name Unused.
 252      * @param array $details Unused.
 253      * @param cache_definition $definition
 254      * @return boolean|cache_store
 255      */
 256     public function create_store_from_config($name, array $details, cache_definition $definition) {
 257         return $this->create_dummy_store($definition);
 258     }
 259
 260     /**
 261      * Creates a cache config instance with the ability to write if required.
 262      *
 263      * @param bool $writer Unused.
 264      * @return cache_config_disabled|cache_config_writer
 265      */
 266     public function create_config_instance($writer = false) {
 267         // We are always going to use the cache_config_disabled class for all regular request.
 268         // However if the code has requested the writer then likely something is changing and
 269         // we're going to need to interact with the config.php file.
 270         // In this case we will still use the cache_config_writer.
 271         $class = 'cache_config_disabled';
 272         if ($writer) {
 273             // If the writer was requested then something is changing.
 274             $class = 'cache_config_writer';
 275         }
 276         if (!array_key_exists($class, $this->configs)) {
 277             self::set_state(self::STATE_INITIALISING);
 278             if ($class === 'cache_config_disabled') {
 279                 $configuration = $class::create_default_configuration();
 280             } else {
 281                 $configuration = false;
 282                 if (!cache_config::config_file_exists()) {
 283                     cache_config_writer::create_default_configuration(true);
 284                 }
 285             }
 286             $this->configs[$class] = new $class;
 287             $this->configs[$class]->load($configuration);
 288         }
 289         self::set_state(self::STATE_READY);
 290
 291         // Return the instance.
 292         return $this->configs[$class];
 293     }
 294 }
 295
 296 /**
 297  * The cache config class used when the Cache has been disabled.
 298  *
 299  * @copyright  2012 Sam Hemelryk
 300  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 301  */
 302 class cache_config_disabled extends cache_config_writer {
 303
 304     /**
 305      * Returns an instance of the configuration writer.
 306      *
 307      * @return cache_config_disabled
 308      */
 309     public static function instance() {
 310         $factory = cache_factory::instance();
 311         return $factory->create_config_instance(true);
 312     }
 313
 314     /**
 315      * Saves the current configuration.
 316      */
 317     protected function config_save() {
 318         // Nothing to do here.
 319     }
 320
 321     /**
 322      * Generates a configuration array suitable to be written to the config file.
 323      *
 324      * @return array
 325      */
 326     protected function generate_configuration_array() {
 327         $configuration = array();
 328         $configuration['stores'] = $this->configstores;
 329         $configuration['modemappings'] = $this->configmodemappings;
 330         $configuration['definitions'] = $this->configdefinitions;
 331         $configuration['definitionmappings'] = $this->configdefinitionmappings;
 332         $configuration['locks'] = $this->configlocks;
 333         return $configuration;
 334     }
 335
 336     /**
 337      * Adds a plugin instance.
 338      *
 339      * @param string $name Unused.
 340      * @param string $plugin Unused.
 341      * @param array $configuration Unused.
 342      * @return bool
 343      * @throws cache_exception
 344      */
 345     public function add_store_instance($name, $plugin, array $configuration = array()) {
 346         return false;
 347     }
 348
 349     /**
 350      * Sets the mode mappings.
 351      *
 352      * @param array $modemappings Unused.
 353      * @return bool
 354      * @throws cache_exception
 355      */
 356     public function set_mode_mappings(array $modemappings) {
 357         return false;
 358     }
 359
 360     /**
 361      * Edits a give plugin instance.
 362      *
 363      * @param string $name Unused.
 364      * @param string $plugin Unused.
 365      * @param array $configuration Unused.
 366      * @return bool
 367      * @throws cache_exception
 368      */
 369     public function edit_store_instance($name, $plugin, $configuration) {
 370         return false;
 371     }
 372
 373     /**
 374      * Deletes a store instance.
 375      *
 376      * @param string $name Unused.
 377      * @return bool
 378      * @throws cache_exception
 379      */
 380     public function delete_store_instance($name) {
 381         return false;
 382     }
 383
 384     /**
 385      * Creates the default configuration and saves it.
 386      *
 387      * @param bool $forcesave Ignored because we are disabled!
 388      * @return array
 389      */
 390     public static function create_default_configuration($forcesave = false) {
 391         global $CFG;
 392
 393         // HACK ALERT.
 394         // We probably need to come up with a better way to create the default stores, or at least ensure 100% that the
 395         // default store plugins are protected from deletion.
 396         require_once($CFG->dirroot.'/cache/stores/file/lib.php');
 397         require_once($CFG->dirroot.'/cache/stores/session/lib.php');
 398         require_once($CFG->dirroot.'/cache/stores/static/lib.php');
 399
 400         $writer = new self;
 401         $writer->configstores = array(
 402             'default_application' => array(
 403                 'name' => 'default_application',
 404                 'plugin' => 'file',
 405                 'configuration' => array(),
 406                 'features' => cachestore_file::get_supported_features(),
 407                 'modes' => cache_store::MODE_APPLICATION,
 408                 'default' => true,
 409             ),
 410             'default_session' => array(
 411                 'name' => 'default_session',
 412                 'plugin' => 'session',
 413                 'configuration' => array(),
 414                 'features' => cachestore_session::get_supported_features(),
 415                 'modes' => cache_store::MODE_SESSION,
 416                 'default' => true,
 417             ),
 418             'default_request' => array(
 419                 'name' => 'default_request',
 420                 'plugin' => 'static',
 421                 'configuration' => array(),
 422                 'features' => cachestore_static::get_supported_features(),
 423                 'modes' => cache_store::MODE_REQUEST,
 424                 'default' => true,
 425             )
 426         );
 427         $writer->configdefinitions = array();
 428         $writer->configmodemappings = array(
 429             array(
 430                 'mode' => cache_store::MODE_APPLICATION,
 431                 'store' => 'default_application',
 432                 'sort' => -1
 433             ),
 434             array(
 435                 'mode' => cache_store::MODE_SESSION,
 436                 'store' => 'default_session',
 437                 'sort' => -1
 438             ),
 439             array(
 440                 'mode' => cache_store::MODE_REQUEST,
 441                 'store' => 'default_request',
 442                 'sort' => -1
 443             )
 444         );
 445         $writer->configlocks = array(
 446             'default_file_lock' => array(
 447                 'name' => 'cachelock_file_default',
 448                 'type' => 'cachelock_file',
 449                 'dir' => 'filelocks',
 450                 'default' => true
 451             )
 452         );
 453
 454         return $writer->generate_configuration_array();
 455     }
 456
 457     /**
 458      * Updates the definition in the configuration from those found in the cache files.
 459      *
 460      * @param bool $coreonly Unused.
 461      */
 462     public static function update_definitions($coreonly = false) {
 463         // Nothing to do here.
 464     }
 465
 466     /**
 467      * Locates all of the definition files.
 468      *
 469      * @param bool $coreonly Unused.
 470      * @return array
 471      */
 472     protected static function locate_definitions($coreonly = false) {
 473         return array();
 474     }
 475
 476     /**
 477      * Sets the mappings for a given definition.
 478      *
 479      * @param string $definition Unused.
 480      * @param array $mappings Unused.
 481      * @throws coding_exception
 482      */
 483     public function set_definition_mappings($definition, $mappings) {
 484         // Nothing to do here.
 485     }
 486 }