Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/config/ResourceCheckerConfigCache.php line 163

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