Search moodle.org's
Developer Documentation


  • Bug fixes for general core bugs in 2.8.x ended 9 November 2015 (12 months).
  • Bug fixes for security issues in 2.8.x ended 9 May 2016 (18 months).
  • minimum PHP 5.4.4 (always use latest PHP 5.4.x or 5.5.x on Windows - http://windows.php.net/download/), PHP 7 is NOT supported
  • Differences Between: [Versions 28 and 30] [Versions 28 and 31] [Versions 28 and 32] [Versions 28 and 33] [Versions 28 and 34] [Versions 28 and 35] [Versions 28 and 36] [Versions 28 and 37]

       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  }
    

    Search This Site: