Yiisoft\FileCache\FileCache

Complexity

Total Complexity

55

Size/Duplication

Total Lines	319
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getMultiple()	0	8	2
A	setMultiple()	0	6	2
A	getCacheFile()	0	14	4
A	setFileMode()	0	3	1
A	gc()	0	4	2
A	setGcProbability()	0	3	1
A	initCacheDirectory()	0	4	2
A	deleteMultiple()	0	6	2
A	setDirMode()	0	3	1
A	setCacheFileSuffix()	0	3	1
B	removeCacheFiles()	0	22	11
A	clear()	0	4	1
A	ttlToExpiration()	0	13	3
A	get()	0	15	3
A	createDirectory()	0	3	3
A	__construct()	0	5	1
A	delete()	0	3	1
A	setDirectoryLevel()	0	3	1
A	normalizeTtl()	0	11	3
A	has()	0	3	1
B	set()	0	33	9

<?php declare(strict_types=1);

namespace Yiisoft\Cache\File;

use DateInterval;
use DateTime;
use Psr\SimpleCache\CacheInterface;
use Yiisoft\Serializer\PhpSerializer;
use Yiisoft\Serializer\SerializerInterface;

/**
 * FileCache implements a cache handler using files.
 *
 * For each data value being cached, FileCache will store it in a separate file.
 * The cache files are placed under {@see FileCache::$cachePath}. FileCache will perform garbage collection
 * automatically to remove expired cache files.
 *
 * Please refer to {@see \Psr\SimpleCache\CacheInterface} for common cache operations that are supported by FileCache.
 */
final class FileCache implements CacheInterface
{
    private const TTL_INFINITY = 31536000; // 1 year
    private const EXPIRATION_EXPIRED = -1;

    /**
     * @var string the directory to store cache files. You may use [path alias](guide:concept-aliases) here.
     */
    private $cachePath;
    /**
     * @var string cache file suffix. Defaults to '.bin'.
     */
    private $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.
     */
    private $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.
     */
    private $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.
     */
    private $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.
     */
    private $dirMode = 0775;

    /**
     * @var SerializerInterface the serializer to be used for serializing and unserializing of the cached data.
     */
    private $serializer;

    public function __construct(string $cachePath, ?SerializerInterface $serializer = null)
    {
        $this->cachePath = $cachePath;
        $this->serializer = $serializer ?? new PhpSerializer();
        $this->initCacheDirectory();
    }

    public function get($key, $default = null)
    {
        if ($this->existsAndNotExpired($key)) {
            $fp = @fopen($this->getCacheFile($key), 'rb');
            if ($fp !== false) {
                @flock($fp, LOCK_SH);

It seems like you do not handle an error condition for flock(). This can introduce security issues, and is generally not recommended.

                $cacheValue = @stream_get_contents($fp);
                @flock($fp, LOCK_UN);
                @fclose($fp);

It seems like you do not handle an error condition for fclose(). This can introduce security issues, and is generally not recommended.

                $cacheValue = $this->serializer->unserialize($cacheValue);
                return $cacheValue;
            }
        }

        return $default;
    }

    public function set($key, $value, $ttl = null): bool
    {
        $this->gc();

        $expiration = $this->ttlToExpiration($ttl);
        if ($expiration < 0) {
            return $this->delete($key);
        }

        $cacheFile = $this->getCacheFile($key);
        if ($this->directoryLevel > 0) {
            $directoryName = \dirname($cacheFile);
            if (!$this->createDirectory($directoryName, $this->dirMode)) {
                return false;
            }
        }
        // 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 (\function_exists('posix_geteuid') && is_file($cacheFile) && fileowner($cacheFile) !== posix_geteuid()) {
            @unlink($cacheFile);

It seems like you do not handle an error condition for unlink(). This can introduce security issues, and is generally not recommended.

        }

        $value = $this->serializer->serialize($value);

        if (@file_put_contents($cacheFile, $value, LOCK_EX) !== false) {
            if ($this->fileMode !== null) {
                @chmod($cacheFile, $this->fileMode);

It seems like you do not handle an error condition for chmod(). This can introduce security issues, and is generally not recommended.

            }
            return @touch($cacheFile, $expiration);
        }

        return false;
    }

    public function delete($key): bool
    {
        return @unlink($this->getCacheFile($key));
    }

    public function clear(): bool
    {
        $this->removeCacheFiles($this->cachePath, false);
        return true;
    }

    public function getMultiple($keys, $default = null): iterable
    {
        $results = [];
        foreach ($keys as $key) {
            $value = $this->get($key, $default);
            $results[$key] = $value;
        }
        return $results;
    }

    public function setMultiple($values, $ttl = null): bool
    {
        foreach ($values as $key => $value) {
            $this->set($key, $value, $ttl);
        }
        return true;
    }

    public function deleteMultiple($keys): bool
    {
        foreach ($keys as $key) {
            $this->delete($key);
        }
        return true;
    }

    public function has($key): bool
    {
        return $this->existsAndNotExpired($key);
    }

    /**
     * Converts TTL to expiration
     * @param int|DateInterval|null $ttl
     * @return int
     */
    private function ttlToExpiration($ttl): int
    {
        $ttl = $this->normalizeTtl($ttl);

        if ($ttl === null) {
            $expiration = static::TTL_INFINITY + time();
        } elseif ($ttl <= 0) {
            $expiration = static::EXPIRATION_EXPIRED;
        } else {
            $expiration = $ttl + time();
        }

        return $expiration;
    }

    /**
     * @noinspection PhpDocMissingThrowsInspection DateTime won't throw exception because constant string is passed as time
     *
     * Normalizes cache TTL handling strings and {@see DateInterval} objects.
     * @param int|string|DateInterval|null $ttl raw TTL.
     * @return int|null TTL value as UNIX timestamp or null meaning infinity
     */
    private function normalizeTtl($ttl): ?int
    {
        if ($ttl instanceof DateInterval) {
            return (new DateTime('@0'))->add($ttl)->getTimestamp();
        }

        if (is_string($ttl)) {
            return (int)$ttl;
        }

        return $ttl;
    }

    /**
     * Ensures that cache directory exists.
     */
    private function initCacheDirectory(): void
    {
        if (!$this->createDirectory($this->cachePath, $this->dirMode)) {
            throw new CacheException('Failed to create cache directory "' . $this->cachePath . '"');
        }
    }

    private function createDirectory(string $path, int $mode): bool
    {
        return is_dir($path) || (mkdir($path, $mode, true) && is_dir($path));
    }

    /**
     * Returns the cache file path given the cache key.
     * @param string $key cache key
     * @return string the cache file path
     */
    private function getCacheFile(string $key): string
    {
        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;
        }

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

    /**
     * Removes expired cache files
     * @throws \Exception
     */
    public function gc(): void
    {
        if (\random_int(0, 1000000) < $this->gcProbability) {
            $this->removeCacheFiles($this->cachePath, true);
        }
    }

    /**
     * Recursively removing expired cache files under a directory.
     * This method is mainly used by {@see 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.
     */
    private function removeCacheFiles(string $path, bool $expiredOnly): void
    {
        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->removeCacheFiles($fullPath, $expiredOnly);
                    if (!$expiredOnly && !@rmdir($fullPath)) {
                        $error = error_get_last();
                        throw new CacheException("Unable to remove directory '{$fullPath}': {$error['message']}");
                    }
                } elseif (!$expiredOnly || ($expiredOnly && @filemtime($fullPath) < time())) {
                    if (!@unlink($fullPath)) {
                        $error = error_get_last();
                        throw new CacheException("Unable to remove file '{$fullPath}': {$error['message']}");
                    }
                }
            }
            closedir($handle);
        }
    }

    /**
     * @param string $cacheFileSuffix cache file suffix. Defaults to '.bin'.
     */
    public function setCacheFileSuffix(string $cacheFileSuffix): void
    {
        $this->cacheFileSuffix = $cacheFileSuffix;
    }

    /**
     * @param int $gcProbability 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 function setGcProbability(int $gcProbability): void
    {
        $this->gcProbability = $gcProbability;
    }

    /**
     * @param int $fileMode 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 function setFileMode(int $fileMode): void
    {
        $this->fileMode = $fileMode;
    }

    /**
     * @param int $dirMode 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 function setDirMode(int $dirMode): void
    {
        $this->dirMode = $dirMode;
    }

    /**
     * @param int $directoryLevel 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 function setDirectoryLevel(int $directoryLevel): void
    {
        $this->directoryLevel = $directoryLevel;
    }

    /**
     * @param string $key
     * @return bool
     */
    private function existsAndNotExpired(string $key): bool
    {
        return @filemtime($this->getCacheFile($key)) > time();
    }
}