mirror of
https://github.com/silverstripe/silverstripe-framework
synced 2024-07-29 06:43:57 +02:00
565 lines
19 KiB
PHP
565 lines
19 KiB
PHP
<?php
|
|
/**
|
|
* Zend Framework
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://framework.zend.com/license/new-bsd
|
|
* If you did not receive a copy of the license and are unable to
|
|
* obtain it through the world-wide-web, please send an email
|
|
* to license@zend.com so we can send you a copy immediately.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Cache
|
|
* @subpackage Zend_Cache_Backend
|
|
* @copyright Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
* @version $Id: Static.php 23775 2011-03-01 17:25:24Z ralph $
|
|
*/
|
|
|
|
/**
|
|
* @see Zend_Cache_Backend_Interface
|
|
*/
|
|
require_once 'Zend/Cache/Backend/Interface.php';
|
|
|
|
/**
|
|
* @see Zend_Cache_Backend
|
|
*/
|
|
require_once 'Zend/Cache/Backend.php';
|
|
|
|
/**
|
|
* @package Zend_Cache
|
|
* @subpackage Zend_Cache_Backend
|
|
* @copyright Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
class Zend_Cache_Backend_Static
|
|
extends Zend_Cache_Backend
|
|
implements Zend_Cache_Backend_Interface
|
|
{
|
|
const INNER_CACHE_NAME = 'zend_cache_backend_static_tagcache';
|
|
|
|
/**
|
|
* Static backend options
|
|
* @var array
|
|
*/
|
|
protected $_options = array(
|
|
'public_dir' => null,
|
|
'sub_dir' => 'html',
|
|
'file_extension' => '.html',
|
|
'index_filename' => 'index',
|
|
'file_locking' => true,
|
|
'cache_file_umask' => 0600,
|
|
'cache_directory_umask' => 0700,
|
|
'debug_header' => false,
|
|
'tag_cache' => null,
|
|
'disable_caching' => false
|
|
);
|
|
|
|
/**
|
|
* Cache for handling tags
|
|
* @var Zend_Cache_Core
|
|
*/
|
|
protected $_tagCache = null;
|
|
|
|
/**
|
|
* Tagged items
|
|
* @var array
|
|
*/
|
|
protected $_tagged = null;
|
|
|
|
/**
|
|
* Interceptor child method to handle the case where an Inner
|
|
* Cache object is being set since it's not supported by the
|
|
* standard backend interface
|
|
*
|
|
* @param string $name
|
|
* @param mixed $value
|
|
* @return Zend_Cache_Backend_Static
|
|
*/
|
|
public function setOption($name, $value)
|
|
{
|
|
if ($name == 'tag_cache') {
|
|
$this->setInnerCache($value);
|
|
} else {
|
|
parent::setOption($name, $value);
|
|
}
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Retrieve any option via interception of the parent's statically held
|
|
* options including the local option for a tag cache.
|
|
*
|
|
* @param string $name
|
|
* @return mixed
|
|
*/
|
|
public function getOption($name)
|
|
{
|
|
if ($name == 'tag_cache') {
|
|
return $this->getInnerCache();
|
|
} else {
|
|
if (in_array($name, $this->_options)) {
|
|
return $this->_options[$name];
|
|
}
|
|
if ($name == 'lifetime') {
|
|
return parent::getLifetime();
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test if a cache is available for the given id and (if yes) return it (false else)
|
|
*
|
|
* Note : return value is always "string" (unserialization is done by the core not by the backend)
|
|
*
|
|
* @param string $id Cache id
|
|
* @param boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
|
|
* @return string|false cached datas
|
|
*/
|
|
public function load($id, $doNotTestCacheValidity = false)
|
|
{
|
|
if (($id = (string)$id) === '') {
|
|
$id = $this->_detectId();
|
|
} else {
|
|
$id = $this->_decodeId($id);
|
|
}
|
|
if (!$this->_verifyPath($id)) {
|
|
Zend_Cache::throwException('Invalid cache id: does not match expected public_dir path');
|
|
}
|
|
if ($doNotTestCacheValidity) {
|
|
$this->_log("Zend_Cache_Backend_Static::load() : \$doNotTestCacheValidity=true is unsupported by the Static backend");
|
|
}
|
|
|
|
$fileName = basename($id);
|
|
if ($fileName === '') {
|
|
$fileName = $this->_options['index_filename'];
|
|
}
|
|
$pathName = $this->_options['public_dir'] . dirname($id);
|
|
$file = rtrim($pathName, '/') . '/' . $fileName . $this->_options['file_extension'];
|
|
if (file_exists($file)) {
|
|
$content = file_get_contents($file);
|
|
return $content;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Test if a cache is available or not (for the given id)
|
|
*
|
|
* @param string $id cache id
|
|
* @return bool
|
|
*/
|
|
public function test($id)
|
|
{
|
|
$id = $this->_decodeId($id);
|
|
if (!$this->_verifyPath($id)) {
|
|
Zend_Cache::throwException('Invalid cache id: does not match expected public_dir path');
|
|
}
|
|
|
|
$fileName = basename($id);
|
|
if ($fileName === '') {
|
|
$fileName = $this->_options['index_filename'];
|
|
}
|
|
if ($this->_tagged === null && $tagged = $this->getInnerCache()->load(self::INNER_CACHE_NAME)) {
|
|
$this->_tagged = $tagged;
|
|
} elseif (!$this->_tagged) {
|
|
return false;
|
|
}
|
|
$pathName = $this->_options['public_dir'] . dirname($id);
|
|
|
|
// Switch extension if needed
|
|
if (isset($this->_tagged[$id])) {
|
|
$extension = $this->_tagged[$id]['extension'];
|
|
} else {
|
|
$extension = $this->_options['file_extension'];
|
|
}
|
|
$file = $pathName . '/' . $fileName . $extension;
|
|
if (file_exists($file)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Save some string datas into a cache record
|
|
*
|
|
* Note : $data is always "string" (serialization is done by the
|
|
* core not by the backend)
|
|
*
|
|
* @param string $data Datas to cache
|
|
* @param string $id Cache id
|
|
* @param array $tags Array of strings, the cache record will be tagged by each string entry
|
|
* @param int $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
|
|
* @return boolean true if no problem
|
|
*/
|
|
public function save($data, $id, $tags = array(), $specificLifetime = false)
|
|
{
|
|
if ($this->_options['disable_caching']) {
|
|
return true;
|
|
}
|
|
$extension = null;
|
|
if ($this->_isSerialized($data)) {
|
|
$data = unserialize($data);
|
|
$extension = '.' . ltrim($data[1], '.');
|
|
$data = $data[0];
|
|
}
|
|
|
|
clearstatcache();
|
|
if (($id = (string)$id) === '') {
|
|
$id = $this->_detectId();
|
|
} else {
|
|
$id = $this->_decodeId($id);
|
|
}
|
|
|
|
$fileName = basename($id);
|
|
if ($fileName === '') {
|
|
$fileName = $this->_options['index_filename'];
|
|
}
|
|
|
|
$pathName = realpath($this->_options['public_dir']) . dirname($id);
|
|
$this->_createDirectoriesFor($pathName);
|
|
|
|
if ($id === null || strlen($id) == 0) {
|
|
$dataUnserialized = unserialize($data);
|
|
$data = $dataUnserialized['data'];
|
|
}
|
|
$ext = $this->_options['file_extension'];
|
|
if ($extension) $ext = $extension;
|
|
$file = rtrim($pathName, '/') . '/' . $fileName . $ext;
|
|
if ($this->_options['file_locking']) {
|
|
$result = file_put_contents($file, $data, LOCK_EX);
|
|
} else {
|
|
$result = file_put_contents($file, $data);
|
|
}
|
|
@chmod($file, $this->_octdec($this->_options['cache_file_umask']));
|
|
|
|
if ($this->_tagged === null && $tagged = $this->getInnerCache()->load(self::INNER_CACHE_NAME)) {
|
|
$this->_tagged = $tagged;
|
|
} elseif ($this->_tagged === null) {
|
|
$this->_tagged = array();
|
|
}
|
|
if (!isset($this->_tagged[$id])) {
|
|
$this->_tagged[$id] = array();
|
|
}
|
|
if (!isset($this->_tagged[$id]['tags'])) {
|
|
$this->_tagged[$id]['tags'] = array();
|
|
}
|
|
$this->_tagged[$id]['tags'] = array_unique(array_merge($this->_tagged[$id]['tags'], $tags));
|
|
$this->_tagged[$id]['extension'] = $ext;
|
|
$this->getInnerCache()->save($this->_tagged, self::INNER_CACHE_NAME);
|
|
return (bool) $result;
|
|
}
|
|
|
|
/**
|
|
* Recursively create the directories needed to write the static file
|
|
*/
|
|
protected function _createDirectoriesFor($path)
|
|
{
|
|
if (!is_dir($path)) {
|
|
$oldUmask = umask(0);
|
|
if ( !@mkdir($path, $this->_octdec($this->_options['cache_directory_umask']), true)) {
|
|
$lastErr = error_get_last();
|
|
umask($oldUmask);
|
|
Zend_Cache::throwException("Can't create directory: {$lastErr['message']}");
|
|
}
|
|
umask($oldUmask);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Detect serialization of data (cannot predict since this is the only way
|
|
* to obey the interface yet pass in another parameter).
|
|
*
|
|
* In future, ZF 2.0, check if we can just avoid the interface restraints.
|
|
*
|
|
* This format is the only valid one possible for the class, so it's simple
|
|
* to just run a regular expression for the starting serialized format.
|
|
*/
|
|
protected function _isSerialized($data)
|
|
{
|
|
return preg_match("/a:2:\{i:0;s:\d+:\"/", $data);
|
|
}
|
|
|
|
/**
|
|
* Remove a cache record
|
|
*
|
|
* @param string $id Cache id
|
|
* @return boolean True if no problem
|
|
*/
|
|
public function remove($id)
|
|
{
|
|
if (!$this->_verifyPath($id)) {
|
|
Zend_Cache::throwException('Invalid cache id: does not match expected public_dir path');
|
|
}
|
|
$fileName = basename($id);
|
|
if ($this->_tagged === null && $tagged = $this->getInnerCache()->load(self::INNER_CACHE_NAME)) {
|
|
$this->_tagged = $tagged;
|
|
} elseif (!$this->_tagged) {
|
|
return false;
|
|
}
|
|
if (isset($this->_tagged[$id])) {
|
|
$extension = $this->_tagged[$id]['extension'];
|
|
} else {
|
|
$extension = $this->_options['file_extension'];
|
|
}
|
|
if ($fileName === '') {
|
|
$fileName = $this->_options['index_filename'];
|
|
}
|
|
$pathName = $this->_options['public_dir'] . dirname($id);
|
|
$file = realpath($pathName) . '/' . $fileName . $extension;
|
|
if (!file_exists($file)) {
|
|
return false;
|
|
}
|
|
return unlink($file);
|
|
}
|
|
|
|
/**
|
|
* Remove a cache record recursively for the given directory matching a
|
|
* REQUEST_URI based relative path (deletes the actual file matching this
|
|
* in addition to the matching directory)
|
|
*
|
|
* @param string $id Cache id
|
|
* @return boolean True if no problem
|
|
*/
|
|
public function removeRecursively($id)
|
|
{
|
|
if (!$this->_verifyPath($id)) {
|
|
Zend_Cache::throwException('Invalid cache id: does not match expected public_dir path');
|
|
}
|
|
$fileName = basename($id);
|
|
if ($fileName === '') {
|
|
$fileName = $this->_options['index_filename'];
|
|
}
|
|
$pathName = $this->_options['public_dir'] . dirname($id);
|
|
$file = $pathName . '/' . $fileName . $this->_options['file_extension'];
|
|
$directory = $pathName . '/' . $fileName;
|
|
if (file_exists($directory)) {
|
|
if (!is_writable($directory)) {
|
|
return false;
|
|
}
|
|
if (is_dir($directory)) {
|
|
foreach (new DirectoryIterator($directory) as $file) {
|
|
if (true === $file->isFile()) {
|
|
if (false === unlink($file->getPathName())) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
rmdir($directory);
|
|
}
|
|
if (file_exists($file)) {
|
|
if (!is_writable($file)) {
|
|
return false;
|
|
}
|
|
return unlink($file);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Clean some cache records
|
|
*
|
|
* Available modes are :
|
|
* Zend_Cache::CLEANING_MODE_ALL (default) => remove all cache entries ($tags is not used)
|
|
* Zend_Cache::CLEANING_MODE_OLD => remove too old cache entries ($tags is not used)
|
|
* Zend_Cache::CLEANING_MODE_MATCHING_TAG => remove cache entries matching all given tags
|
|
* ($tags can be an array of strings or a single string)
|
|
* Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
|
|
* ($tags can be an array of strings or a single string)
|
|
* Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
|
|
* ($tags can be an array of strings or a single string)
|
|
*
|
|
* @param string $mode Clean mode
|
|
* @param array $tags Array of tags
|
|
* @return boolean true if no problem
|
|
*/
|
|
public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
|
|
{
|
|
$result = false;
|
|
switch ($mode) {
|
|
case Zend_Cache::CLEANING_MODE_MATCHING_TAG:
|
|
case Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG:
|
|
if (empty($tags)) {
|
|
throw new Zend_Exception('Cannot use tag matching modes as no tags were defined');
|
|
}
|
|
if ($this->_tagged === null && $tagged = $this->getInnerCache()->load(self::INNER_CACHE_NAME)) {
|
|
$this->_tagged = $tagged;
|
|
} elseif (!$this->_tagged) {
|
|
return true;
|
|
}
|
|
foreach ($tags as $tag) {
|
|
$urls = array_keys($this->_tagged);
|
|
foreach ($urls as $url) {
|
|
if (isset($this->_tagged[$url]['tags']) && in_array($tag, $this->_tagged[$url]['tags'])) {
|
|
$this->remove($url);
|
|
unset($this->_tagged[$url]);
|
|
}
|
|
}
|
|
}
|
|
$this->getInnerCache()->save($this->_tagged, self::INNER_CACHE_NAME);
|
|
$result = true;
|
|
break;
|
|
case Zend_Cache::CLEANING_MODE_ALL:
|
|
if ($this->_tagged === null) {
|
|
$tagged = $this->getInnerCache()->load(self::INNER_CACHE_NAME);
|
|
$this->_tagged = $tagged;
|
|
}
|
|
if ($this->_tagged === null || empty($this->_tagged)) {
|
|
return true;
|
|
}
|
|
$urls = array_keys($this->_tagged);
|
|
foreach ($urls as $url) {
|
|
$this->remove($url);
|
|
unset($this->_tagged[$url]);
|
|
}
|
|
$this->getInnerCache()->save($this->_tagged, self::INNER_CACHE_NAME);
|
|
$result = true;
|
|
break;
|
|
case Zend_Cache::CLEANING_MODE_OLD:
|
|
$this->_log("Zend_Cache_Backend_Static : Selected Cleaning Mode Currently Unsupported By This Backend");
|
|
break;
|
|
case Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG:
|
|
if (empty($tags)) {
|
|
throw new Zend_Exception('Cannot use tag matching modes as no tags were defined');
|
|
}
|
|
if ($this->_tagged === null) {
|
|
$tagged = $this->getInnerCache()->load(self::INNER_CACHE_NAME);
|
|
$this->_tagged = $tagged;
|
|
}
|
|
if ($this->_tagged === null || empty($this->_tagged)) {
|
|
return true;
|
|
}
|
|
$urls = array_keys($this->_tagged);
|
|
foreach ($urls as $url) {
|
|
$difference = array_diff($tags, $this->_tagged[$url]['tags']);
|
|
if (count($tags) == count($difference)) {
|
|
$this->remove($url);
|
|
unset($this->_tagged[$url]);
|
|
}
|
|
}
|
|
$this->getInnerCache()->save($this->_tagged, self::INNER_CACHE_NAME);
|
|
$result = true;
|
|
break;
|
|
default:
|
|
Zend_Cache::throwException('Invalid mode for clean() method');
|
|
break;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Set an Inner Cache, used here primarily to store Tags associated
|
|
* with caches created by this backend. Note: If Tags are lost, the cache
|
|
* should be completely cleaned as the mapping of tags to caches will
|
|
* have been irrevocably lost.
|
|
*
|
|
* @param Zend_Cache_Core
|
|
* @return void
|
|
*/
|
|
public function setInnerCache(Zend_Cache_Core $cache)
|
|
{
|
|
$this->_tagCache = $cache;
|
|
$this->_options['tag_cache'] = $cache;
|
|
}
|
|
|
|
/**
|
|
* Get the Inner Cache if set
|
|
*
|
|
* @return Zend_Cache_Core
|
|
*/
|
|
public function getInnerCache()
|
|
{
|
|
if ($this->_tagCache === null) {
|
|
Zend_Cache::throwException('An Inner Cache has not been set; use setInnerCache()');
|
|
}
|
|
return $this->_tagCache;
|
|
}
|
|
|
|
/**
|
|
* Verify path exists and is non-empty
|
|
*
|
|
* @param string $path
|
|
* @return bool
|
|
*/
|
|
protected function _verifyPath($path)
|
|
{
|
|
$path = realpath($path);
|
|
$base = realpath($this->_options['public_dir']);
|
|
return strncmp($path, $base, strlen($base)) !== 0;
|
|
}
|
|
|
|
/**
|
|
* Determine the page to save from the request
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function _detectId()
|
|
{
|
|
return $_SERVER['REQUEST_URI'];
|
|
}
|
|
|
|
/**
|
|
* Validate a cache id or a tag (security, reliable filenames, reserved prefixes...)
|
|
*
|
|
* Throw an exception if a problem is found
|
|
*
|
|
* @param string $string Cache id or tag
|
|
* @throws Zend_Cache_Exception
|
|
* @return void
|
|
* @deprecated Not usable until perhaps ZF 2.0
|
|
*/
|
|
protected static function _validateIdOrTag($string)
|
|
{
|
|
if (!is_string($string)) {
|
|
Zend_Cache::throwException('Invalid id or tag : must be a string');
|
|
}
|
|
|
|
// Internal only checked in Frontend - not here!
|
|
if (substr($string, 0, 9) == 'internal-') {
|
|
return;
|
|
}
|
|
|
|
// Validation assumes no query string, fragments or scheme included - only the path
|
|
if (!preg_match(
|
|
'/^(?:\/(?:(?:%[[:xdigit:]]{2}|[A-Za-z0-9-_.!~*\'()\[\]:@&=+$,;])*)?)+$/',
|
|
$string
|
|
)
|
|
) {
|
|
Zend_Cache::throwException("Invalid id or tag '$string' : must be a valid URL path");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Detect an octal string and return its octal value for file permission ops
|
|
* otherwise return the non-string (assumed octal or decimal int already)
|
|
*
|
|
* @param string $val The potential octal in need of conversion
|
|
* @return int
|
|
*/
|
|
protected function _octdec($val)
|
|
{
|
|
if (is_string($val) && decoct(octdec($val)) == $val) {
|
|
return octdec($val);
|
|
}
|
|
return $val;
|
|
}
|
|
|
|
/**
|
|
* Decode a request URI from the provided ID
|
|
*
|
|
* @param string $id
|
|
* @return string
|
|
*/
|
|
protected function _decodeId($id)
|
|
{
|
|
return pack('H*', $id);
|
|
}
|
|
}
|