[Summary view] [Print] [Text view]

   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          $definition = $this->create_definition($component, $area);
 216          $cache = $this->create_cache($definition, $identifiers);
 217          return $cache;
 218      }
 219  
 220      /**
 221       * Creates an ad-hoc cache from the given param.
 222       *
 223       * @param int $mode
 224       * @param string $component
 225       * @param string $area
 226       * @param array $identifiers
 227       * @param array $options An array of options, available options are:
 228       *   - simplekeys : Set to true if the keys you will use are a-zA-Z0-9_
 229       *   - simpledata : Set to true if the type of the data you are going to store is scalar, or an array of scalar vars
 230       *   - staticacceleration : If set to true the cache will hold onto all data passing through it.
 231       *   - staticaccelerationsize : Sets the max size of the static acceleration array.
 232       * @return cache_application|cache_session|cache_request
 233       */
 234      public function create_cache_from_params($mode, $component, $area, array $identifiers = array(), array $options = array()) {
 235          $definition = cache_definition::load_adhoc($mode, $component, $area);
 236          $cache = $this->create_cache($definition, $identifiers);
 237          return $cache;
 238      }
 239  
 240      /**
 241       * Creates a store instance given its name and configuration.
 242       *
 243       * @param string $name Unused.
 244       * @param array $details Unused.
 245       * @param cache_definition $definition
 246       * @return boolean|cache_store
 247       */
 248      public function create_store_from_config($name, array $details, cache_definition $definition) {
 249          return $this->create_dummy_store($definition);
 250      }
 251  
 252      /**
 253       * Creates a cache config instance with the ability to write if required.
 254       *
 255       * @param bool $writer Unused.
 256       * @return cache_config_disabled|cache_config_writer
 257       */
 258      public function create_config_instance($writer = false) {
 259          // We are always going to use the cache_config_disabled class for all regular request.
 260          // However if the code has requested the writer then likely something is changing and
 261          // we're going to need to interact with the config.php file.
 262          // In this case we will still use the cache_config_writer.
 263          $class = 'cache_config_disabled';
 264          if ($writer) {
 265              // If the writer was requested then something is changing.
 266              $class = 'cache_config_writer';
 267          }
 268          if (!array_key_exists($class, $this->configs)) {
 269              self::set_state(self::STATE_INITIALISING);
 270              if ($class === 'cache_config_disabled') {
 271                  $configuration = $class::create_default_configuration();
 272              } else {
 273                  $configuration = false;
 274                  if (!cache_config::config_file_exists()) {
 275                      cache_config_writer::create_default_configuration(true);
 276                  }
 277              }
 278              $this->configs[$class] = new $class;
 279              $this->configs[$class]->load($configuration);
 280          }
 281          self::set_state(self::STATE_READY);
 282  
 283          // Return the instance.
 284          return $this->configs[$class];
 285      }
 286  }
 287  
 288  /**
 289   * The cache config class used when the Cache has been disabled.
 290   *
 291   * @copyright  2012 Sam Hemelryk
 292   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 293   */
 294  class cache_config_disabled extends cache_config_writer {
 295  
 296      /**
 297       * Returns an instance of the configuration writer.
 298       *
 299       * @return cache_config_disabled
 300       */
 301      public static function instance() {
 302          $factory = cache_factory::instance();
 303          return $factory->create_config_instance(true);
 304      }
 305  
 306      /**
 307       * Saves the current configuration.
 308       */
 309      protected function config_save() {
 310          // Nothing to do here.
 311      }
 312  
 313      /**
 314       * Generates a configuration array suitable to be written to the config file.
 315       *
 316       * @return array
 317       */
 318      protected function generate_configuration_array() {
 319          $configuration = array();
 320          $configuration['stores'] = $this->configstores;
 321          $configuration['modemappings'] = $this->configmodemappings;
 322          $configuration['definitions'] = $this->configdefinitions;
 323          $configuration['definitionmappings'] = $this->configdefinitionmappings;
 324          $configuration['locks'] = $this->configlocks;
 325          return $configuration;
 326      }
 327  
 328      /**
 329       * Adds a plugin instance.
 330       *
 331       * @param string $name Unused.
 332       * @param string $plugin Unused.
 333       * @param array $configuration Unused.
 334       * @return bool
 335       * @throws cache_exception
 336       */
 337      public function add_store_instance($name, $plugin, array $configuration = array()) {
 338          return false;
 339      }
 340  
 341      /**
 342       * Sets the mode mappings.
 343       *
 344       * @param array $modemappings Unused.
 345       * @return bool
 346       * @throws cache_exception
 347       */
 348      public function set_mode_mappings(array $modemappings) {
 349          return false;
 350      }
 351  
 352      /**
 353       * Edits a give plugin instance.
 354       *
 355       * @param string $name Unused.
 356       * @param string $plugin Unused.
 357       * @param array $configuration Unused.
 358       * @return bool
 359       * @throws cache_exception
 360       */
 361      public function edit_store_instance($name, $plugin, $configuration) {
 362          return false;
 363      }
 364  
 365      /**
 366       * Deletes a store instance.
 367       *
 368       * @param string $name Unused.
 369       * @return bool
 370       * @throws cache_exception
 371       */
 372      public function delete_store_instance($name) {
 373          return false;
 374      }
 375  
 376      /**
 377       * Creates the default configuration and saves it.
 378       *
 379       * @param bool $forcesave Ignored because we are disabled!
 380       * @return array
 381       */
 382      public static function create_default_configuration($forcesave = false) {
 383          global $CFG;
 384  
 385          // HACK ALERT.
 386          // We probably need to come up with a better way to create the default stores, or at least ensure 100% that the
 387          // default store plugins are protected from deletion.
 388          require_once($CFG->dirroot.'/cache/stores/file/lib.php');
 389          require_once($CFG->dirroot.'/cache/stores/session/lib.php');
 390          require_once($CFG->dirroot.'/cache/stores/static/lib.php');
 391  
 392          $writer = new self;
 393          $writer->configstores = array(
 394              'default_application' => array(
 395                  'name' => 'default_application',
 396                  'plugin' => 'file',
 397                  'configuration' => array(),
 398                  'features' => cachestore_file::get_supported_features(),
 399                  'modes' => cache_store::MODE_APPLICATION,
 400                  'default' => true,
 401              ),
 402              'default_session' => array(
 403                  'name' => 'default_session',
 404                  'plugin' => 'session',
 405                  'configuration' => array(),
 406                  'features' => cachestore_session::get_supported_features(),
 407                  'modes' => cache_store::MODE_SESSION,
 408                  'default' => true,
 409              ),
 410              'default_request' => array(
 411                  'name' => 'default_request',
 412                  'plugin' => 'static',
 413                  'configuration' => array(),
 414                  'features' => cachestore_static::get_supported_features(),
 415                  'modes' => cache_store::MODE_REQUEST,
 416                  'default' => true,
 417              )
 418          );
 419          $writer->configdefinitions = array();
 420          $writer->configmodemappings = array(
 421              array(
 422                  'mode' => cache_store::MODE_APPLICATION,
 423                  'store' => 'default_application',
 424                  'sort' => -1
 425              ),
 426              array(
 427                  'mode' => cache_store::MODE_SESSION,
 428                  'store' => 'default_session',
 429                  'sort' => -1
 430              ),
 431              array(
 432                  'mode' => cache_store::MODE_REQUEST,
 433                  'store' => 'default_request',
 434                  'sort' => -1
 435              )
 436          );
 437          $writer->configlocks = array(
 438              'default_file_lock' => array(
 439                  'name' => 'cachelock_file_default',
 440                  'type' => 'cachelock_file',
 441                  'dir' => 'filelocks',
 442                  'default' => true
 443              )
 444          );
 445  
 446          return $writer->generate_configuration_array();
 447      }
 448  
 449      /**
 450       * Updates the definition in the configuration from those found in the cache files.
 451       *
 452       * @param bool $coreonly Unused.
 453       */
 454      public static function update_definitions($coreonly = false) {
 455          // Nothing to do here.
 456      }
 457  
 458      /**
 459       * Locates all of the definition files.
 460       *
 461       * @param bool $coreonly Unused.
 462       * @return array
 463       */
 464      protected static function locate_definitions($coreonly = false) {
 465          return array();
 466      }
 467  
 468      /**
 469       * Sets the mappings for a given definition.
 470       *
 471       * @param string $definition Unused.
 472       * @param array $mappings Unused.
 473       * @throws coding_exception
 474       */
 475      public function set_definition_mappings($definition, $mappings) {
 476          // Nothing to do here.
 477      }
 478  }