mirror of
https://github.com/yiisoft/yii2.git
synced 2025-10-31 18:47:33 +08:00
287 lines
11 KiB
PHP
287 lines
11 KiB
PHP
<?php
|
|
/**
|
|
* @link http://www.yiiframework.com/
|
|
* @copyright Copyright (c) 2008 Yii Software LLC
|
|
* @license http://www.yiiframework.com/license/
|
|
*/
|
|
|
|
namespace yii\caching;
|
|
|
|
use Yii;
|
|
use yii\helpers\FileHelper;
|
|
|
|
/**
|
|
* FileCache implements a cache component using files.
|
|
*
|
|
* For each data value being cached, FileCache will store it in a separate file.
|
|
* The cache files are placed under [[cachePath]]. FileCache will perform garbage collection
|
|
* automatically to remove expired cache files.
|
|
*
|
|
* Please refer to [[Cache]] for common cache operations that are supported by FileCache.
|
|
*
|
|
* For more details and usage information on Cache, see the [guide article on caching](guide:caching-overview).
|
|
*
|
|
* @author Qiang Xue <qiang.xue@gmail.com>
|
|
* @since 2.0
|
|
*/
|
|
class FileCache extends Cache
|
|
{
|
|
/**
|
|
* @var string a string prefixed to every cache key. This is needed when you store
|
|
* cache data under the same [[cachePath]] for different applications to avoid
|
|
* conflict.
|
|
*
|
|
* To ensure interoperability, only alphanumeric characters should be used.
|
|
*/
|
|
public $keyPrefix = '';
|
|
/**
|
|
* @var string the directory to store cache files. You may use [path alias](guide:concept-aliases) here.
|
|
* If not set, it will use the "cache" subdirectory under the application runtime path.
|
|
*/
|
|
public $cachePath = '@runtime/cache';
|
|
/**
|
|
* @var string cache file suffix. Defaults to '.bin'.
|
|
*/
|
|
public $cacheFileSuffix = '.bin';
|
|
/**
|
|
* @var int the level of sub-directories to store cache files. Defaults to 1.
|
|
* If the system has huge number of cache files (e.g. one million), you may use a bigger value
|
|
* (usually no bigger than 3). Using sub-directories is mainly to ensure the file system
|
|
* is not over burdened with a single directory having too many files.
|
|
*/
|
|
public $directoryLevel = 1;
|
|
/**
|
|
* @var int the probability (parts per million) that garbage collection (GC) should be performed
|
|
* when storing a piece of data in the cache. Defaults to 10, meaning 0.001% chance.
|
|
* This number should be between 0 and 1000000. A value 0 means no GC will be performed at all.
|
|
*/
|
|
public $gcProbability = 10;
|
|
/**
|
|
* @var int the permission to be set for newly created cache files.
|
|
* This value will be used by PHP chmod() function. No umask will be applied.
|
|
* If not set, the permission will be determined by the current environment.
|
|
*/
|
|
public $fileMode;
|
|
/**
|
|
* @var int the permission to be set for newly created directories.
|
|
* This value will be used by PHP chmod() function. No umask will be applied.
|
|
* Defaults to 0775, meaning the directory is read-writable by owner and group,
|
|
* but read-only for other users.
|
|
*/
|
|
public $dirMode = 0775;
|
|
|
|
|
|
/**
|
|
* Initializes this component by ensuring the existence of the cache path.
|
|
*/
|
|
public function init()
|
|
{
|
|
parent::init();
|
|
$this->cachePath = Yii::getAlias($this->cachePath);
|
|
if (!is_dir($this->cachePath)) {
|
|
FileHelper::createDirectory($this->cachePath, $this->dirMode, true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether a specified key exists in the cache.
|
|
* This can be faster than getting the value from the cache if the data is big.
|
|
* Note that this method does not check whether the dependency associated
|
|
* with the cached data, if there is any, has changed. So a call to [[get]]
|
|
* may return false while exists returns true.
|
|
* @param mixed $key a key identifying the cached value. This can be a simple string or
|
|
* a complex data structure consisting of factors representing the key.
|
|
* @return bool true if a value exists in cache, false if the value is not in the cache or expired.
|
|
*/
|
|
public function exists($key)
|
|
{
|
|
$cacheFile = $this->getCacheFile($this->buildKey($key));
|
|
|
|
return @filemtime($cacheFile) > time();
|
|
}
|
|
|
|
/**
|
|
* Retrieves a value from cache with a specified key.
|
|
* This is the implementation of the method declared in the parent class.
|
|
* @param string $key a unique key identifying the cached value
|
|
* @return string|false the value stored in cache, false if the value is not in the cache or expired.
|
|
*/
|
|
protected function getValue($key)
|
|
{
|
|
$cacheFile = $this->getCacheFile($key);
|
|
|
|
if (@filemtime($cacheFile) > time()) {
|
|
$fp = @fopen($cacheFile, 'r');
|
|
if ($fp !== false) {
|
|
@flock($fp, LOCK_SH);
|
|
$cacheValue = @stream_get_contents($fp);
|
|
@flock($fp, LOCK_UN);
|
|
@fclose($fp);
|
|
return $cacheValue;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Stores a value identified by a key in cache.
|
|
* This is the implementation of the method declared in the parent class.
|
|
*
|
|
* @param string $key the key identifying the value to be cached
|
|
* @param string $value the value to be cached. Other types (If you have disabled [[serializer]]) unable to get is
|
|
* correct in [[getValue()]].
|
|
* @param int $duration the number of seconds in which the cached value will expire. 0 means never expire.
|
|
* @return bool true if the value is successfully stored into cache, false otherwise
|
|
*/
|
|
protected function setValue($key, $value, $duration)
|
|
{
|
|
$this->gc();
|
|
$cacheFile = $this->getCacheFile($key);
|
|
if ($this->directoryLevel > 0) {
|
|
@FileHelper::createDirectory(dirname($cacheFile), $this->dirMode, true);
|
|
}
|
|
// If ownership differs the touch call will fail, so we try to
|
|
// rebuild the file from scratch by deleting it first
|
|
// https://github.com/yiisoft/yii2/pull/16120
|
|
if (is_file($cacheFile) && function_exists('posix_geteuid') && fileowner($cacheFile) !== posix_geteuid()) {
|
|
@unlink($cacheFile);
|
|
}
|
|
if (@file_put_contents($cacheFile, $value, LOCK_EX) !== false) {
|
|
if ($this->fileMode !== null) {
|
|
@chmod($cacheFile, $this->fileMode);
|
|
}
|
|
if ($duration <= 0) {
|
|
$duration = 31536000; // 1 year
|
|
}
|
|
|
|
return @touch($cacheFile, $duration + time());
|
|
}
|
|
|
|
$error = error_get_last();
|
|
Yii::warning("Unable to write cache file '{$cacheFile}': {$error['message']}", __METHOD__);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Stores a value identified by a key into cache if the cache does not contain this key.
|
|
* This is the implementation of the method declared in the parent class.
|
|
*
|
|
* @param string $key the key identifying the value to be cached
|
|
* @param string $value the value to be cached. Other types (if you have disabled [[serializer]]) unable to get is
|
|
* correct in [[getValue()]].
|
|
* @param int $duration the number of seconds in which the cached value will expire. 0 means never expire.
|
|
* @return bool true if the value is successfully stored into cache, false otherwise
|
|
*/
|
|
protected function addValue($key, $value, $duration)
|
|
{
|
|
$cacheFile = $this->getCacheFile($key);
|
|
if (@filemtime($cacheFile) > time()) {
|
|
return false;
|
|
}
|
|
|
|
return $this->setValue($key, $value, $duration);
|
|
}
|
|
|
|
/**
|
|
* Deletes a value with the specified key from cache
|
|
* This is the implementation of the method declared in the parent class.
|
|
* @param string $key the key of the value to be deleted
|
|
* @return bool if no error happens during deletion
|
|
*/
|
|
protected function deleteValue($key)
|
|
{
|
|
$cacheFile = $this->getCacheFile($key);
|
|
|
|
return @unlink($cacheFile);
|
|
}
|
|
|
|
/**
|
|
* Returns the cache file path given the normalized cache key.
|
|
* @param string $normalizedKey normalized cache key by [[buildKey]] method
|
|
* @return string the cache file path
|
|
*/
|
|
protected function getCacheFile($normalizedKey)
|
|
{
|
|
$cacheKey = $normalizedKey;
|
|
|
|
if ($this->keyPrefix !== '') {
|
|
// Remove key prefix to avoid generating constant directory levels
|
|
$lenKeyPrefix = strlen($this->keyPrefix);
|
|
$cacheKey = substr_replace($normalizedKey, '', 0, $lenKeyPrefix);
|
|
}
|
|
|
|
$cachePath = $this->cachePath;
|
|
|
|
if ($this->directoryLevel > 0) {
|
|
for ($i = 0; $i < $this->directoryLevel; ++$i) {
|
|
if (($subDirectory = substr($cacheKey, $i + $i, 2)) !== false) {
|
|
$cachePath .= DIRECTORY_SEPARATOR . $subDirectory;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $cachePath . DIRECTORY_SEPARATOR . $normalizedKey . $this->cacheFileSuffix;
|
|
}
|
|
|
|
/**
|
|
* Deletes all values from cache.
|
|
* This is the implementation of the method declared in the parent class.
|
|
* @return bool whether the flush operation was successful.
|
|
*/
|
|
protected function flushValues()
|
|
{
|
|
$this->gc(true, false);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Removes expired cache files.
|
|
* @param bool $force whether to enforce the garbage collection regardless of [[gcProbability]].
|
|
* Defaults to false, meaning the actual deletion happens with the probability as specified by [[gcProbability]].
|
|
* @param bool $expiredOnly whether to removed expired cache files only.
|
|
* If false, all cache files under [[cachePath]] will be removed.
|
|
*/
|
|
public function gc($force = false, $expiredOnly = true)
|
|
{
|
|
if ($force || random_int(0, 1000000) < $this->gcProbability) {
|
|
$this->gcRecursive($this->cachePath, $expiredOnly);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Recursively removing expired cache files under a directory.
|
|
* This method is mainly used by [[gc()]].
|
|
* @param string $path the directory under which expired cache files are removed.
|
|
* @param bool $expiredOnly whether to only remove expired cache files. If false, all files
|
|
* under `$path` will be removed.
|
|
*/
|
|
protected function gcRecursive($path, $expiredOnly)
|
|
{
|
|
if (($handle = opendir($path)) !== false) {
|
|
while (($file = readdir($handle)) !== false) {
|
|
if (strncmp($file, '.', 1) === 0) {
|
|
continue;
|
|
}
|
|
$fullPath = $path . DIRECTORY_SEPARATOR . $file;
|
|
if (is_dir($fullPath)) {
|
|
$this->gcRecursive($fullPath, $expiredOnly);
|
|
if (!$expiredOnly) {
|
|
if (!@rmdir($fullPath)) {
|
|
$error = error_get_last();
|
|
Yii::warning("Unable to remove directory '{$fullPath}': {$error['message']}", __METHOD__);
|
|
}
|
|
}
|
|
} elseif (!$expiredOnly || $expiredOnly && @filemtime($fullPath) < time()) {
|
|
if (!@unlink($fullPath)) {
|
|
$error = error_get_last();
|
|
Yii::warning("Unable to remove file '{$fullPath}': {$error['message']}", __METHOD__);
|
|
}
|
|
}
|
|
}
|
|
closedir($handle);
|
|
}
|
|
}
|
|
}
|