vendor/symfony/config/ResourceCheckerConfigCache.php line 65

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\Config;
  11. use Symfony\Component\Config\Resource\ResourceInterface;
  12. use Symfony\Component\Filesystem\Exception\IOException;
  13. use Symfony\Component\Filesystem\Filesystem;
  14. /**
  15.  * ResourceCheckerConfigCache uses instances of ResourceCheckerInterface
  16.  * to check whether cached data is still fresh.
  17.  *
  18.  * @author Matthias Pigulla <mp@webfactory.de>
  19.  */
  20. class ResourceCheckerConfigCache implements ConfigCacheInterface
  21. {
  22.     /**
  23.      * @var string
  24.      */
  25.     private $file;
  26.     /**
  27.      * @var iterable<mixed, ResourceCheckerInterface>
  28.      */
  29.     private $resourceCheckers;
  30.     /**
  31.      * @param string                                    $file             The absolute cache path
  32.      * @param iterable<mixed, ResourceCheckerInterface> $resourceCheckers The ResourceCheckers to use for the freshness check
  33.      */
  34.     public function __construct(string $fileiterable $resourceCheckers = [])
  35.     {
  36.         $this->file $file;
  37.         $this->resourceCheckers $resourceCheckers;
  38.     }
  39.     /**
  40.      * {@inheritdoc}
  41.      */
  42.     public function getPath()
  43.     {
  44.         return $this->file;
  45.     }
  46.     /**
  47.      * Checks if the cache is still fresh.
  48.      *
  49.      * This implementation will make a decision solely based on the ResourceCheckers
  50.      * passed in the constructor.
  51.      *
  52.      * The first ResourceChecker that supports a given resource is considered authoritative.
  53.      * Resources with no matching ResourceChecker will silently be ignored and considered fresh.
  54.      *
  55.      * @return bool
  56.      */
  57.     public function isFresh()
  58.     {
  59.         if (!is_file($this->file)) {
  60.             return false;
  61.         }
  62.         if ($this->resourceCheckers instanceof \Traversable && !$this->resourceCheckers instanceof \Countable) {
  63.             $this->resourceCheckers iterator_to_array($this->resourceCheckers);
  64.         }
  65.         if (!\count($this->resourceCheckers)) {
  66.             return true// shortcut - if we don't have any checkers we don't need to bother with the meta file at all
  67.         }
  68.         $metadata $this->getMetaFile();
  69.         if (!is_file($metadata)) {
  70.             return false;
  71.         }
  72.         $meta $this->safelyUnserialize($metadata);
  73.         if (false === $meta) {
  74.             return false;
  75.         }
  76.         $time filemtime($this->file);
  77.         foreach ($meta as $resource) {
  78.             foreach ($this->resourceCheckers as $checker) {
  79.                 if (!$checker->supports($resource)) {
  80.                     continue; // next checker
  81.                 }
  82.                 if ($checker->isFresh($resource$time)) {
  83.                     break; // no need to further check this resource
  84.                 }
  85.                 return false// cache is stale
  86.             }
  87.             // no suitable checker found, ignore this resource
  88.         }
  89.         return true;
  90.     }
  91.     /**
  92.      * Writes cache.
  93.      *
  94.      * @param string              $content  The content to write in the cache
  95.      * @param ResourceInterface[] $metadata An array of metadata
  96.      *
  97.      * @throws \RuntimeException When cache file can't be written
  98.      */
  99.     public function write(string $content, array $metadata null)
  100.     {
  101.         $mode 0666;
  102.         $umask umask();
  103.         $filesystem = new Filesystem();
  104.         $filesystem->dumpFile($this->file$content);
  105.         try {
  106.             $filesystem->chmod($this->file$mode$umask);
  107.         } catch (IOException $e) {
  108.             // discard chmod failure (some filesystem may not support it)
  109.         }
  110.         if (null !== $metadata) {
  111.             $filesystem->dumpFile($this->getMetaFile(), serialize($metadata));
  112.             try {
  113.                 $filesystem->chmod($this->getMetaFile(), $mode$umask);
  114.             } catch (IOException $e) {
  115.                 // discard chmod failure (some filesystem may not support it)
  116.             }
  117.         }
  118.         if (\function_exists('opcache_invalidate') && filter_var(\ini_get('opcache.enable'), \FILTER_VALIDATE_BOOLEAN)) {
  119.             @opcache_invalidate($this->filetrue);
  120.         }
  121.     }
  122.     /**
  123.      * Gets the meta file path.
  124.      */
  125.     private function getMetaFile(): string
  126.     {
  127.         return $this->file.'.meta';
  128.     }
  129.     private function safelyUnserialize(string $file)
  130.     {
  131.         $meta false;
  132.         $content file_get_contents($file);
  133.         $signalingException = new \UnexpectedValueException();
  134.         $prevUnserializeHandler ini_set('unserialize_callback_func'self::class.'::handleUnserializeCallback');
  135.         $prevErrorHandler set_error_handler(function ($type$msg$file$line$context = []) use (&$prevErrorHandler$signalingException) {
  136.             if (__FILE__ === $file) {
  137.                 throw $signalingException;
  138.             }
  139.             return $prevErrorHandler $prevErrorHandler($type$msg$file$line$context) : false;
  140.         });
  141.         try {
  142.             $meta unserialize($content);
  143.         } catch (\Throwable $e) {
  144.             if ($e !== $signalingException) {
  145.                 throw $e;
  146.             }
  147.         } finally {
  148.             restore_error_handler();
  149.             ini_set('unserialize_callback_func'$prevUnserializeHandler);
  150.         }
  151.         return $meta;
  152.     }
  153.     /**
  154.      * @internal
  155.      */
  156.     public static function handleUnserializeCallback(string $class)
  157.     {
  158.         trigger_error('Class not found: '.$class);
  159.     }
  160. }