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         if ($loader instanceof cache_data_source) {
  53             // Set the data source to allow data sources to work when caching is entirely disabled.
  54             $this->set_data_source($loader);
  55         }
  56
  57         // No other features are handled.
  58     }
  59
  60     /**
  61      * Gets a key from the cache.
  62      *
  63      * @param int|string $key
  64      * @param int $strictness Unused.
  65      * @return bool
  66      */
  67     public function get($key, $strictness = IGNORE_MISSING) {
  68         if ($this->get_datasource() !== false) {
  69             return $this->get_datasource()->load_for_cache($key);
  70         }
  71
  72         return false;
  73     }
  74
  75     /**
  76      * Gets many keys at once from the cache.
  77      *
  78      * @param array $keys
  79      * @param int $strictness Unused.
  80      * @return array
  81      */
  82     public function get_many(array $keys, $strictness = IGNORE_MISSING) {
  83         if ($this->get_datasource() !== false) {
  84             return $this->get_datasource()->load_many_for_cache($keys);
  85         }
  86
  87         return array_combine($keys, array_fill(0, count($keys), false));
  88     }
  89
  90     /**
  91      * Sets a key value pair in the cache.
  92      *
  93      * @param int|string $key Unused.
  94      * @param mixed $data Unused.
  95      * @return bool
  96      */
  97     public function set($key, $data) {
  98         return false;
  99     }
 100
 101     /**
 102      * Sets many key value pairs in the cache at once.
 103      *
 104      * @param array $keyvaluearray Unused.
 105      * @return int
 106      */
 107     public function set_many(array $keyvaluearray) {
 108         return 0;
 109     }
 110
 111     /**
 112      * Deletes an item from the cache.
 113      *
 114      * @param int|string $key Unused.
 115      * @param bool $recurse Unused.
 116      * @return bool
 117      */
 118     public function delete($key, $recurse = true) {
 119         return false;
 120     }
 121
 122     /**
 123      * Deletes many items at once from the cache.
 124      *
 125      * @param array $keys Unused.
 126      * @param bool $recurse Unused.
 127      * @return int
 128      */
 129     public function delete_many(array $keys, $recurse = true) {
 130         return 0;
 131     }
 132
 133     /**
 134      * Checks if the cache has the requested key.
 135      *
 136      * @param int|string $key Unused.
 137      * @param bool $tryloadifpossible Unused.
 138      * @return bool
 139      */
 140     public function has($key, $tryloadifpossible = false) {
 141         $result = $this->get($key);
 142
 143         return $result !== false;
 144     }
 145
 146     /**
 147      * Checks if the cache has all of the requested keys.
 148      * @param array $keys Unused.
 149      * @return bool
 150      */
 151     public function has_all(array $keys) {
 152         if (!$this->get_datasource()) {
 153             return false;
 154         }
 155
 156         foreach ($keys as $key) {
 157             if (!$this->has($key)) {
 158                 return false;
 159             }
 160         }
 161         return true;
 162     }
 163
 164     /**
 165      * Checks if the cache has any of the requested keys.
 166      *
 167      * @param array $keys Unused.
 168      * @return bool
 169      */
 170     public function has_any(array $keys) {
 171         foreach ($keys as $key) {
 172             if ($this->has($key)) {
 173                 return true;
 174             }
 175         }
 176
 177         return false;
 178     }
 179
 180     /**
 181      * Purges all items from the cache.
 182      *
 183      * @return bool
 184      */
 185     public function purge() {
 186         return true;
 187     }
 188 }
 189
 190 /**
 191  * The cache factory class used when the Cache has been disabled.
 192  *
 193  * @copyright  2012 Sam Hemelryk
 194  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 195  */
 196 class cache_factory_disabled extends cache_factory {
 197
 198     /**
 199      * Returns an instance of the cache_factor method.
 200      *
 201      * @param bool $forcereload Unused.
 202      * @return cache_factory
 203      * @throws coding_exception
 204      */
 205     public static function instance($forcereload = false) {
 206         throw new coding_exception('You must not call to this cache factory within your code.');
 207     }
 208
 209     /**
 210      * Creates a definition instance or returns the existing one if it has already been created.
 211      *
 212      * @param string $component
 213      * @param string $area
 214      * @param string $unused Used to be datasourceaggregate but that was removed and this is now unused.
 215      * @return cache_definition
 216      */
 217     public function create_definition($component, $area, $unused = null) {
 218         $definition = parent::create_definition($component, $area);
 219         if ($definition->has_data_source()) {
 220             return $definition;
 221         }
 222
 223         return cache_definition::load_adhoc(cache_store::MODE_REQUEST, $component, $area);
 224     }
 225
 226     /**
 227      * Common public method to create a cache instance given a definition.
 228      *
 229      * @param cache_definition $definition
 230      * @return cache_application|cache_session|cache_store
 231      * @throws coding_exception
 232      */
 233     public function create_cache(cache_definition $definition) {
 234         $loader = null;
 235         if ($definition->has_data_source()) {
 236             $loader = $definition->get_data_source();
 237         }
 238         return new cache_disabled($definition, $this->create_dummy_store($definition), $loader);
 239     }
 240
 241     /**
 242      * Creates a cache object given the parameters for a definition.
 243      *
 244      * @param string $component
 245      * @param string $area
 246      * @param array $identifiers
 247      * @param string $unused Used to be datasourceaggregate but that was removed and this is now unused.
 248      * @return cache_application|cache_session|cache_request
 249      */
 250     public function create_cache_from_definition($component, $area, array $identifiers = array(), $unused = null) {
 251         // Regular cache definitions are cached inside create_definition().  This is not the case for disabledlib.php
 252         // definitions as they use load_adhoc().  They are built as a new object on each call.
 253         // We do not need to clone the definition because we know it's new.
 254         $definition = $this->create_definition($component, $area);
 255         $definition->set_identifiers($identifiers);
 256         $cache = $this->create_cache($definition);
 257         return $cache;
 258     }
 259
 260     /**
 261      * Creates an ad-hoc cache from the given param.
 262      *
 263      * @param int $mode
 264      * @param string $component
 265      * @param string $area
 266      * @param array $identifiers
 267      * @param array $options An array of options, available options are:
 268      *   - simplekeys : Set to true if the keys you will use are a-zA-Z0-9_
 269      *   - simpledata : Set to true if the type of the data you are going to store is scalar, or an array of scalar vars
 270      *   - staticacceleration : If set to true the cache will hold onto all data passing through it.
 271      *   - staticaccelerationsize : Sets the max size of the static acceleration array.
 272      * @return cache_application|cache_session|cache_request
 273      */
 274     public function create_cache_from_params($mode, $component, $area, array $identifiers = array(), array $options = array()) {
 275         // Regular cache definitions are cached inside create_definition().  This is not the case for disabledlib.php
 276         // definitions as they use load_adhoc().  They are built as a new object on each call.
 277         // We do not need to clone the definition because we know it's new.
 278         $definition = cache_definition::load_adhoc($mode, $component, $area, $options);
 279         $definition->set_identifiers($identifiers);
 280         $cache = $this->create_cache($definition);
 281         return $cache;
 282     }
 283
 284     /**
 285      * Creates a store instance given its name and configuration.
 286      *
 287      * @param string $name Unused.
 288      * @param array $details Unused.
 289      * @param cache_definition $definition
 290      * @return boolean|cache_store
 291      */
 292     public function create_store_from_config($name, array $details, cache_definition $definition) {
 293         return $this->create_dummy_store($definition);
 294     }
 295
 296     /**
 297      * Creates a cache config instance with the ability to write if required.
 298      *
 299      * @param bool $writer Unused.
 300      * @return cache_config_disabled|cache_config_writer
 301      */
 302     public function create_config_instance($writer = false) {
 303         // We are always going to use the cache_config_disabled class for all regular request.
 304         // However if the code has requested the writer then likely something is changing and
 305         // we're going to need to interact with the config.php file.
 306         // In this case we will still use the cache_config_writer.
 307         $class = 'cache_config_disabled';
 308         if ($writer) {
 309             // If the writer was requested then something is changing.
 310             $class = 'cache_config_writer';
 311         }
 312         if (!array_key_exists($class, $this->configs)) {
 313             self::set_state(self::STATE_INITIALISING);
 314             if ($class === 'cache_config_disabled') {
 315                 $configuration = $class::create_default_configuration();
 316                 $this->configs[$class] = new $class;
 317             } else {
 318                 $configuration = false;
 319                 // If we need a writer, we should get the classname from the generic factory.
 320                 // This is so alternative classes can be used if a different writer is required.
 321                 $this->configs[$class] = parent::get_disabled_writer();
 322             }
 323             $this->configs[$class]->load($configuration);
 324         }
 325         self::set_state(self::STATE_READY);
 326
 327         // Return the instance.
 328         return $this->configs[$class];
 329     }
 330
 331     /**
 332      * Returns true if the cache API has been disabled.
 333      *
 334      * @return bool
 335      */
 336     public function is_disabled() {
 337         return true;
 338     }
 339 }
 340
 341 /**
 342  * The cache config class used when the Cache has been disabled.
 343  *
 344  * @copyright  2012 Sam Hemelryk
 345  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 346  */
 347 class cache_config_disabled extends cache_config_writer {
 348
 349     /**
 350      * Returns an instance of the configuration writer.
 351      *
 352      * @return cache_config_disabled
 353      */
 354     public static function instance() {
 355         $factory = cache_factory::instance();
 356         return $factory->create_config_instance(true);
 357     }
 358
 359     /**
 360      * Saves the current configuration.
 361      */
 362     protected function config_save() {
 363         // Nothing to do here.
 364     }
 365
 366     /**
 367      * Generates a configuration array suitable to be written to the config file.
 368      *
 369      * @return array
 370      */
 371     protected function generate_configuration_array() {
 372         $configuration = array();
 373         $configuration['stores'] = $this->configstores;
 374         $configuration['modemappings'] = $this->configmodemappings;
 375         $configuration['definitions'] = $this->configdefinitions;
 376         $configuration['definitionmappings'] = $this->configdefinitionmappings;
 377         $configuration['locks'] = $this->configlocks;
 378         return $configuration;
 379     }
 380
 381     /**
 382      * Adds a plugin instance.
 383      *
 384      * @param string $name Unused.
 385      * @param string $plugin Unused.
 386      * @param array $configuration Unused.
 387      * @return bool
 388      * @throws cache_exception
 389      */
 390     public function add_store_instance($name, $plugin, array $configuration = array()) {
 391         return false;
 392     }
 393
 394     /**
 395      * Sets the mode mappings.
 396      *
 397      * @param array $modemappings Unused.
 398      * @return bool
 399      * @throws cache_exception
 400      */
 401     public function set_mode_mappings(array $modemappings) {
 402         return false;
 403     }
 404
 405     /**
 406      * Edits a give plugin instance.
 407      *
 408      * @param string $name Unused.
 409      * @param string $plugin Unused.
 410      * @param array $configuration Unused.
 411      * @return bool
 412      * @throws cache_exception
 413      */
 414     public function edit_store_instance($name, $plugin, $configuration) {
 415         return false;
 416     }
 417
 418     /**
 419      * Deletes a store instance.
 420      *
 421      * @param string $name Unused.
 422      * @return bool
 423      * @throws cache_exception
 424      */
 425     public function delete_store_instance($name) {
 426         return false;
 427     }
 428
 429     /**
 430      * Creates the default configuration and saves it.
 431      *
 432      * @param bool $forcesave Ignored because we are disabled!
 433      * @return array
 434      */
 435     public static function create_default_configuration($forcesave = false) {
 436         global $CFG;
 437
 438         // HACK ALERT.
 439         // We probably need to come up with a better way to create the default stores, or at least ensure 100% that the
 440         // default store plugins are protected from deletion.
 441         require_once($CFG->dirroot.'/cache/stores/file/lib.php');
 442         require_once($CFG->dirroot.'/cache/stores/session/lib.php');
 443         require_once($CFG->dirroot.'/cache/stores/static/lib.php');
 444
 445         $writer = new self;
 446         $writer->configstores = array(
 447             'default_application' => array(
 448                 'name' => 'default_application',
 449                 'plugin' => 'file',
 450                 'configuration' => array(),
 451                 'features' => cachestore_file::get_supported_features(),
 452                 'modes' => cache_store::MODE_APPLICATION,
 453                 'default' => true,
 454             ),
 455             'default_session' => array(
 456                 'name' => 'default_session',
 457                 'plugin' => 'session',
 458                 'configuration' => array(),
 459                 'features' => cachestore_session::get_supported_features(),
 460                 'modes' => cache_store::MODE_SESSION,
 461                 'default' => true,
 462             ),
 463             'default_request' => array(
 464                 'name' => 'default_request',
 465                 'plugin' => 'static',
 466                 'configuration' => array(),
 467                 'features' => cachestore_static::get_supported_features(),
 468                 'modes' => cache_store::MODE_REQUEST,
 469                 'default' => true,
 470             )
 471         );
 472         $writer->configdefinitions = array();
 473         $writer->configmodemappings = array(
 474             array(
 475                 'mode' => cache_store::MODE_APPLICATION,
 476                 'store' => 'default_application',
 477                 'sort' => -1
 478             ),
 479             array(
 480                 'mode' => cache_store::MODE_SESSION,
 481                 'store' => 'default_session',
 482                 'sort' => -1
 483             ),
 484             array(
 485                 'mode' => cache_store::MODE_REQUEST,
 486                 'store' => 'default_request',
 487                 'sort' => -1
 488             )
 489         );
 490         $writer->configlocks = array(
 491             'default_file_lock' => array(
 492                 'name' => 'cachelock_file_default',
 493                 'type' => 'cachelock_file',
 494                 'dir' => 'filelocks',
 495                 'default' => true
 496             )
 497         );
 498
 499         return $writer->generate_configuration_array();
 500     }
 501
 502     /**
 503      * Updates the definition in the configuration from those found in the cache files.
 504      *
 505      * @param bool $coreonly Unused.
 506      */
 507     public static function update_definitions($coreonly = false) {
 508         // Nothing to do here.
 509     }
 510
 511     /**
 512      * Locates all of the definition files.
 513      *
 514      * @param bool $coreonly Unused.
 515      * @return array
 516      */
 517     protected static function locate_definitions($coreonly = false) {
 518         return array();
 519     }
 520
 521     /**
 522      * Sets the mappings for a given definition.
 523      *
 524      * @param string $definition Unused.
 525      * @param array $mappings Unused.
 526      * @throws coding_exception
 527      */
 528     public function set_definition_mappings($definition, $mappings) {
 529         // Nothing to do here.
 530     }
 531 }