WebSVN – Moodle – Diff – /cache/stores/file/lib.php

 // 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/>.
-/**
- * The library file for the file cache store.
- *
+use core_cache\configurable_cache_interface;
- * This file is part of the file cache store, it contains the API for interacting with an instance of the store.
+use core_cache\definition;
- * This is used as a default cache store within the Cache API. It should never be deleted.
- *
+use core_cache\key_aware_cache_interface;
- * @package    cachestore_file
+use core_cache\lockable_cache_interface;
- * @category   cache
+use core_cache\searchable_cache_interface;
- * @copyright  2012 Sam Hemelryk
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
+use core_cache\store;
 /**
  * The file store class.
+ *
  * Configuration options
  *      path:           string: path to the cache directory, if left empty one will be created in the cache directory
  *      autocreate:     true, false
+ *      prescan:        true, false
  *      prescan:        true, false
  * @package    cachestore_file
  * @copyright  2012 Sam Hemelryk
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class cachestore_file extends store implements
+    key_aware_cache_interface,
- */
+    configurable_cache_interface,
+    searchable_cache_interface,
+    lockable_cache_interface
+{
+    /**
+     * Value to represent use of the PHP serializer.
+     */
+    public const SERIALIZER_PHP = 'php';
+    /**
+     * Value to represent use of the Igbinary serializer.
-class cachestore_file extends cache_store implements cache_is_key_aware, cache_is_configurable, cache_is_searchable,
+     */
-        cache_is_lockable {
+    public const SERIALIZER_IGBINARY = 'igbinary';
     /**
      */
     protected $isready = false;
     /**
      * The cache definition this instance has been initialised with.
-     * @var cache_definition
+     * @var definition
      */
     protected $definition;
      * @var array $locks
      */
     protected $locks = [];
+    /**
+     * Serializer for this store.
+     *
+     * @var string
+     */
+    protected $serializer = self::SERIALIZER_PHP;
+    /**
+     * Determine if igbinary functions are available for use.
+     *
+     * @return boolean
+     */
+    public static function igbinary_available(): bool {
+        return function_exists('igbinary_serialize');
+    }
+    /**
+     * Gets an array of options to use as the serialiser.
+     *
+     * @return array
+     */
+    public static function config_get_serializer_options(): array {
+        $options = [
+            self::SERIALIZER_PHP => get_string('serializer_php', 'cachestore_file'),
+        ];
+        if (self::igbinary_available()) {
+            $options[self::SERIALIZER_IGBINARY] = get_string('serializer_igbinary', 'cachestore_file');
+        }
+        return $options;
+    }
     /**
      * Constructs the store instance.
+     *
      * Noting that this function is not an initialisation. It is used to prepare the store for use.
-     * The store will be initialised when required and will be provided with a cache_definition at that time.
+     * The store will be initialised when required and will be provided with a definition at that time.
+     *
      * @param string $name
      * @param array $configuration
      */
         $this->lockfactory = new \core\lock\file_lock_factory('cachestore_file', $lockdir);
         if (!$this->lockfactory->is_available()) {
             // File locking is disabled in config, fall back to default lock factory.
             $this->lockfactory = \core\lock\lock_config::get_lock_factory('cachestore_file');
+        }
+        // Set the serializer to use based on configuration.
+        if (array_key_exists('serializer', $configuration)) {
+            $this->serializer = (string)$configuration['serializer'];
+        }
+    }
     /**
      * Performs any necessary operation when the file store instance has been created.
+    }
     /**
      * Returns true if the given mode is supported by this store.
      *
-     * @param int $mode One of cache_store::MODE_*
+     * @param int $mode One of store::MODE_*
      * @return bool
      */
     public static function is_supported_mode($mode) {
-        return ($mode === self::MODE_APPLICATION || $mode === self::MODE_SESSION);
+        return ($mode === static::MODE_APPLICATION || $mode === static::MODE_SESSION);
+    }
     /**
      * Initialises the cache.
+     *
      * Once this has been done the cache is all set to be used.
+     *
-     * @param cache_definition $definition
+     * @param definition $definition
      */
-    public function initialise(cache_definition $definition) {
+    public function initialise(definition $definition) {
         global $CFG;
+     *
      * @param mixed $data
      * @return string
      */
     protected function prep_data_before_save($data) {
-        return serialize($data);
+        return $this->serialize($data);
+    }
     /**
      * Prepares the data it has been read from the cache. Undoing what was done in prep_data_before_save.
+     *
      * @param string $data
      * @param string $path
      * @return mixed
      */
     protected function prep_data_after_read($data, $path) {
-        $result = @unserialize($data);
+        $result = @$this->unserialize($data);
-        if ($result === false && $data != serialize(false)) {
+        if ($result === false && $data != @$this->serialize(false)) {
             debugging('Failed to unserialise data from cache file: ' . $path . '. Data: ' . $data, DEBUG_DEVELOPER);
             return false;
+        }
         return $result;
             $config['asyncpurge'] = $data->asyncpurge;
+        }
         if (isset($data->lockwait)) {
             $config['lockwait'] = $data->lockwait;
+        }
+        if (isset($data->serializer)) {
+            $config['serializer'] = $data->serializer;
+        }
         return $config;
+    }
             $data['asyncpurge'] = (bool)$config['asyncpurge'];
+        }
         if (isset($config['lockwait'])) {
             $data['lockwait'] = (int)$config['lockwait'];
+        }
+        if (isset($config['serializer'])) {
+            $data['serializer'] = (string)$config['serializer'];
+        }
         $editform->set_data($data);
+    }
     /**
     /**
      * Generates an instance of the cache store that can be used for testing.
+     *
      * Returns an instance of the cache store, or false if one cannot be created.
+     *
-     * @param cache_definition $definition
+     * @param definition $definition
      * @return cachestore_file
      */
-    public static function initialise_test_instance(cache_definition $definition) {
+    public static function initialise_test_instance(definition $definition) {
         $name = 'File test';
         $path = make_cache_directory('cachestore_file_test');
         $cache = new cachestore_file($name, array('path' => $path));
         if ($cache->is_ready()) {
             $cache->initialise($definition);
      * Use lock factory to acquire a lock.
+     *
      * @param string $key Lock identifier
      * @param string $ownerid Cache identifier
      * @return bool
-     * @throws cache_exception
      */
     public function acquire_lock($key, $ownerid): bool {
         $lock = $this->lockfactory->get_lock($key, $this->lockwait);
         if ($lock) {
             $this->locks[$key][$ownerid] = $lock;
         if ($unlocked) {
             unset($this->locks[$key]);
+        }
         return $unlocked;
+    }
+    /**
+     * Serializes the data according to the configured serializer.
+     *
+     * @param mixed $value
+     * @return string
+     */
+    protected function serialize($value): string {
+        switch ($this->serializer) {
+            case self::SERIALIZER_PHP:
+                return serialize($value);
+            case self::SERIALIZER_IGBINARY:
+                if (self::igbinary_available()) {
+                    return igbinary_serialize($value);
+                }
+        }
+        debugging("Unknown or unavailable serializer {$this->serializer}");
+        return serialize($value);
+    }
+    /**
+     * Unserializes the data according to the configured serializer.
+     *
+     * @param mixed $value
+     * @return mixed
+     */
+    protected function unserialize($value) {
+        switch ($this->serializer) {
+            case self::SERIALIZER_PHP:
+                return unserialize($value);
+            case self::SERIALIZER_IGBINARY:
+                if (self::igbinary_available()) {
+                    return igbinary_unserialize($value);
+                }
+        }
+        debugging("Unknown or unavailable serializer: {$this->serializer}");
+        return unserialize($value);
+    }
+}

Proyectos de Subversion Moodle

(root)/cache/stores/file/lib.php – Rev 1 → 1441