FileCacheStorage.php

<?php declare(strict_types = 1);

namespace PHPStan\Cache;

use InvalidArgumentException;
use Nette\Utils\Random;
use PHPStan\File\CouldNotReadFileException;
use PHPStan\File\CouldNotWriteFileException;
use PHPStan\File\FileReader;
use PHPStan\File\FileWriter;
use PHPStan\Internal\DirectoryCreator;
use PHPStan\Internal\DirectoryCreatorException;
use PHPStan\ShouldNotHappenException;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use function array_keys;
use function closedir;
use function dirname;
use function error_get_last;
use function file_get_contents;
use function hash;
use function is_dir;
use function is_file;
use function opendir;
use function readdir;
use function rename;
use function rmdir;
use function serialize;
use function sprintf;
use function str_ends_with;
use function strlen;
use function substr;
use function uksort;
use function unlink;
use function unserialize;
use const DIRECTORY_SEPARATOR;

/**
 * Entries are stored as serialize() payloads in *.dat files. They used to be
 * var_export()ed PHP files loaded with include: compiling such a file costs
 * more than unserializing the same data, every hydrated object goes through
 * a userland __set_state() call, and the compiled code stays in memory for the
 * rest of the process - 11 % of the peak memory of a single-process analysis.
 * The separate extension keeps an older PHPStan sharing the directory from
 * including a payload that is not PHP.
 */
final class FileCacheStorage implements CacheStorage
{

	private const CACHED_CLEARED_VERSION = 'v3-serialized';

	public function __construct(private string $directory)
	{
	}

	public function load(string $key, string $variableKey): mixed
	{
		[,, $filePath] = $this->getFilePaths($key);

		// Letting include() fail is an expensive way to learn that an entry was
		// never written: PHP walks the include_path and builds two warnings only
		// to have them discarded by the @, about 29us per miss, while the stat()
		// that rules the file out costs about 1.4us and is free on the hit path
		// (the include stats the file anyway). Misses are not rare - every class
		// name that reaches the PHP-internal locator and turns out not to be a
		// built-in is one, tens of thousands per run and per worker.
		if (!is_file($filePath)) {
			return null;
		}

		$contents = @file_get_contents($filePath);
		if ($contents === false) {
			return null;
		}

		$cacheItem = @unserialize($contents);
		if (!$cacheItem instanceof CacheItem) {
			return null;
		}
		if (!$cacheItem->isVariableKeyValid($variableKey)) {
			return null;
		}

		return $cacheItem->getData();
	}

	/**
	 * @throws DirectoryCreatorException
	 */
	public function save(string $key, string $variableKey, mixed $data): void
	{
		[$firstDirectory, $secondDirectory, $path] = $this->getFilePaths($key);
		DirectoryCreator::ensureDirectoryExists($this->directory, 0777);
		DirectoryCreator::ensureDirectoryExists($firstDirectory, 0777);
		DirectoryCreator::ensureDirectoryExists($secondDirectory, 0777);

		$tmpPath = sprintf('%s/%s.tmp', $this->directory, Random::generate());
		$errorBefore = error_get_last();
		$serialized = @serialize(new CacheItem($variableKey, $data));
		$errorAfter = error_get_last();
		if ($errorAfter !== null && $errorBefore !== $errorAfter) {
			throw new ShouldNotHappenException(sprintf('Error occurred while saving item %s (%s) to cache: %s', $key, $variableKey, $errorAfter['message']));
		}
		FileWriter::write($tmpPath, $serialized);

		$renameSuccess = @rename($tmpPath, $path);
		if ($renameSuccess) {
			return;
		}

		@unlink($tmpPath);
		if (DIRECTORY_SEPARATOR === '/' || !is_file($path)) {
			throw new InvalidArgumentException(sprintf('Could not write data to cache file %s.', $path));
		}
	}

	/**
	 * @param non-empty-string $key
	 *
	 * @return array{string, string, string}
	 */
	private function getFilePaths(string $key): array
	{
		$keyHash = hash('sha256', $key);
		$firstDirectory = sprintf('%s/%s', $this->directory, substr($keyHash, 0, 2));
		$secondDirectory = sprintf('%s/%s', $firstDirectory, substr($keyHash, 2, 2));
		$filePath = sprintf('%s/%s.dat', $secondDirectory, $keyHash);

		return [
			$firstDirectory,
			$secondDirectory,
			$filePath,
		];
	}

	public function clearUnusedFiles(): void
	{
		if (!is_dir($this->directory)) {
			return;
		}

		$cachedClearedFile = $this->directory . '/cache-cleared';
		if (is_file($cachedClearedFile)) {
			try {
				$cachedClearedContents = FileReader::read($cachedClearedFile);
				if ($cachedClearedContents === self::CACHED_CLEARED_VERSION) {
					return;
				}
			} catch (CouldNotReadFileException) {
				return;
			}
		}

		// every entry written before the serialize() format is a *.php file;
		// none of them is read anymore
		$iterator = new RecursiveDirectoryIterator($this->directory);
		$iterator->setFlags(RecursiveDirectoryIterator::SKIP_DOTS);
		$files = new RecursiveIteratorIterator($iterator);
		$emptyDirectoriesToCheck = [];
		foreach ($files as $file) {
			$path = $file->getPathname();
			if (!str_ends_with($path, '.php')) {
				continue;
			}

			$emptyDirectoriesToCheck[dirname($path)] = true;
			$emptyDirectoriesToCheck[dirname($path, 2)] = true;

			@unlink($path);
		}

		uksort($emptyDirectoriesToCheck, static fn ($a, $b) => strlen($b) - strlen($a));

		foreach (array_keys($emptyDirectoriesToCheck) as $directory) {
			if (!$this->isDirectoryEmpty($directory)) {
				continue;
			}

			@rmdir($directory);
		}

		try {
			FileWriter::write($cachedClearedFile, self::CACHED_CLEARED_VERSION);
		} catch (CouldNotWriteFileException) {
			// pass
		}
	}

	private function isDirectoryEmpty(string $directory): bool
	{
		$handle = opendir($directory);
		if ($handle === false) {
			return false;
		}
		while (($entry = readdir($handle)) !== false) {
			if ($entry !== '.' && $entry !== '..') {
				closedir($handle);
				return false;
			}
		}

		closedir($handle);
		return true;
	}

}