<?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.
 *
 * @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 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 integer 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 integer 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 integer 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 integer 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 boolean 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|boolean 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()) {
 return @file_get_contents($cacheFile);
 } else {
 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
 * @param integer $duration the number of seconds in which the cached value will expire. 0 means never expire.
 * @return boolean 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 (@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());
 } else {
 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
 * @param integer $duration the number of seconds in which the cached value will expire. 0 means never expire.
 * @return boolean 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 boolean if no error happens during deletion
 */
 protected function deleteValue($key)
 {
 $cacheFile = $this->getCacheFile($key);

 return @unlink($cacheFile);
 }

 /**
 * Returns the cache file path given the cache key.
 * @param string $key cache key
 * @return string the cache file path
 */
 protected function getCacheFile($key)
 {
 if ($this->directoryLevel > 0) {
 $base = $this->cachePath;
 for ($i = 0; $i < $this->directoryLevel; ++$i) {
 if (($prefix = substr($key, $i + $i, 2)) !== false) {
 $base .= DIRECTORY_SEPARATOR . $prefix;
 }
 }

 return $base . DIRECTORY_SEPARATOR . $key . $this->cacheFileSuffix;
 } else {
 return $this->cachePath . DIRECTORY_SEPARATOR . $key . $this->cacheFileSuffix;
 }
 }

 /**
 * Deletes all values from cache.
 * This is the implementation of the method declared in the parent class.
 * @return boolean whether the flush operation was successful.
 */
 protected function flushValues()
 {
 $this->gc(true, false);

 return true;
 }

 /**
 * Removes expired cache files.
 * @param boolean $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 boolean $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 || mt_rand(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 boolean $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 ($file[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);
 }
 }
}