vendor/jms/metadata/src/Cache/FileCache.php line 25

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Metadata\Cache;
  7. use Metadata\ClassMetadata;
  9. class FileCache implements CacheInterface, ClearableCacheInterface
  10. {
  11.     /**
  12.      * @var string
  13.      */
  14.     private $dir;
  16.     public function __construct(string $dir)
  17.     {
  18.         if (!is_dir($dir) && false === @mkdir($dir, 0777, true)) {
  19.             throw new \InvalidArgumentException(sprintf('Can\'t create directory for cache at "%s"', $dir));
  20.         }
  22.         $this->dir = rtrim($dir, '\\/');
  23.     }
  25.     public function load(string $class): ?ClassMetadata
  26.     {
  27.         $path = $this->getCachePath($class);
  28.         if (!is_readable($path)) {
  29.             return null;
  30.         }
  32.         try {
  33.             $metadata = include $path;
  34.             if ($metadata instanceof ClassMetadata) {
  35.                 return $metadata;
  36.             }
  37.             // if the file does not return anything, the return value is integer `1`.
  38.         } catch (\Error $e) {
  39.             // ignore corrupted cache
  40.         }
  42.         return null;
  43.     }
  45.     public function put(ClassMetadata $metadata): void
  46.     {
  47.         if (!is_writable($this->dir)) {
  48.             throw new \InvalidArgumentException(sprintf('The directory "%s" is not writable.', $this->dir));
  49.         }
  51.         $path = $this->getCachePath($metadata->name);
  52.         if (!is_writable(dirname($path))) {
  53.             throw new \RuntimeException(sprintf('Cache file "%s" is not writable.', $path));
  54.         }
  56.         $tmpFile = tempnam($this->dir, 'metadata-cache');
  57.         if (false === $tmpFile) {
  58.             $this->evict($metadata->name);
  60.             return;
  61.         }
  63.         $data = '<?php return unserialize(' . var_export(serialize($metadata), true) . ');';
  64.         $bytesWritten = file_put_contents($tmpFile, $data);
  65.         // use strlen and not mb_strlen. if there is utf8 in the code, it also writes more bytes.
  66.         if ($bytesWritten !== strlen($data)) {
  67.             @unlink($tmpFile);
  68.             // also evict the cache to not use an outdated version.
  69.             $this->evict($metadata->name);
  71.             return;
  72.         }
  74.         // Let's not break filesystems which do not support chmod.
  75.         @chmod($tmpFile, 0666 & ~umask());
  77.         $this->renameFile($tmpFile, $path);
  78.     }
  80.     /**
  81.      * Renames a file with fallback for windows
  82.      */
  83.     private function renameFile(string $source, string $target): void
  84.     {
  85.         if (false === @rename($source, $target)) {
  86.             if (defined('PHP_WINDOWS_VERSION_BUILD')) {
  87.                 if (false === copy($source, $target)) {
  88.                     throw new \RuntimeException(sprintf('(WIN) Could not write new cache file to %s.', $target));
  89.                 }
  91.                 if (false === unlink($source)) {
  92.                     throw new \RuntimeException(sprintf('(WIN) Could not delete temp cache file to %s.', $source));
  93.                 }
  94.             } else {
  95.                 throw new \RuntimeException(sprintf('Could not write new cache file to %s.', $target));
  96.             }
  97.         }
  98.     }
  100.     public function evict(string $class): void
  101.     {
  102.         $path = $this->getCachePath($class);
  103.         if (file_exists($path)) {
  104.             @unlink($path);
  105.         }
  106.     }
  108.     public function clear(): bool
  109.     {
  110.         $result = true;
  111.         $files = glob($this->dir . '/*.cache.php');
  112.         foreach ($files as $file) {
  113.             if (is_file($file)) {
  114.                 $result = $result && @unlink($file);
  115.             }
  116.         }
  118.         return $result;
  119.     }
  121.     /**
  122.      * This function computes the cache file path.
  123.      *
  124.      * If anonymous class is to be cached, it contains invalid path characters that need to be removed/replaced
  125.      * Example of anonymous class name: class@anonymous\x00/app/src/Controller/DefaultController.php0x7f82a7e026ec
  126.      */
  127.     private function getCachePath(string $key): string
  128.     {
  129.         $fileName = str_replace(['\\', "\0", '@', '/', '$', '{', '}', ':'], '-', $key);
  131.         return $this->dir . '/' . $fileName . '.cache.php';
  132.     }
  133. }