vendor/symfony/cache/Traits/PhpFilesTrait.php line 104

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\Cache\Traits;
  14. use Symfony\Component\Cache\Exception\CacheException;
  15. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  16. use Symfony\Component\VarExporter\VarExporter;
  18. /**
  19.  * @author Piotr Stankowski <git@trakos.pl>
  20.  * @author Nicolas Grekas <p@tchwork.com>
  21.  * @author Rob Frawley 2nd <rmf@src.run>
  22.  *
  23.  * @internal
  24.  */
  25. trait PhpFilesTrait
  26. {
  27.     use FilesystemCommonTrait {
  28.         doClear as private doCommonClear;
  29.         doDelete as private doCommonDelete;
  30.     }
  32.     private $includeHandler;
  33.     private $appendOnly;
  34.     private $values = [];
  35.     private $files = [];
  37.     private static $startTime;
  38.     private static $valuesCache = [];
  40.     public static function isSupported()
  41.     {
  42.         self::$startTime = self::$startTime ?? $_SERVER['REQUEST_TIME'] ?? time();
  44.         return \function_exists('opcache_invalidate') && filter_var(ini_get('opcache.enable'), \FILTER_VALIDATE_BOOLEAN) && (!\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) || filter_var(ini_get('opcache.enable_cli'), \FILTER_VALIDATE_BOOLEAN));
  45.     }
  47.     /**
  48.      * @return bool
  49.      */
  50.     public function prune()
  51.     {
  52.         $time = time();
  53.         $pruned = true;
  54.         $getExpiry = true;
  56.         set_error_handler($this->includeHandler);
  57.         try {
  58.             foreach ($this->scanHashDir($this->directory) as $file) {
  59.                 try {
  60.                     if (\is_array($expiresAt = include $file)) {
  61.                         $expiresAt = $expiresAt[0];
  62.                     }
  63.                 } catch (\ErrorException $e) {
  64.                     $expiresAt = $time;
  65.                 }
  67.                 if ($time >= $expiresAt) {
  68.                     $pruned = $this->doUnlink($file) && !file_exists($file) && $pruned;
  69.                 }
  70.             }
  71.         } finally {
  72.             restore_error_handler();
  73.         }
  75.         return $pruned;
  76.     }
  78.     /**
  79.      * {@inheritdoc}
  80.      */
  81.     protected function doFetch(array $ids)
  82.     {
  83.         if ($this->appendOnly) {
  84.             $now = 0;
  85.             $missingIds = [];
  86.         } else {
  87.             $now = time();
  88.             $missingIds = $ids;
  89.             $ids = [];
  90.         }
  91.         $values = [];
  93.         begin:
  94.         $getExpiry = false;
  96.         foreach ($ids as $id) {
  97.             if (null === $value = $this->values[$id] ?? null) {
  98.                 $missingIds[] = $id;
  99.             } elseif ('N;' === $value) {
  100.                 $values[$id] = null;
  101.             } elseif (!\is_object($value)) {
  102.                 $values[$id] = $value;
  103.             } elseif (!$value instanceof LazyValue) {
  104.                 $values[$id] = $value();
  105.             } elseif (false === $values[$id] = include $value->file) {
  106.                 unset($values[$id], $this->values[$id]);
  107.                 $missingIds[] = $id;
  108.             }
  109.             if (!$this->appendOnly) {
  110.                 unset($this->values[$id]);
  111.             }
  112.         }
  114.         if (!$missingIds) {
  115.             return $values;
  116.         }
  118.         set_error_handler($this->includeHandler);
  119.         try {
  120.             $getExpiry = true;
  122.             foreach ($missingIds as $k => $id) {
  123.                 try {
  124.                     $file = $this->files[$id] ?? $this->files[$id] = $this->getFile($id);
  126.                     if (isset(self::$valuesCache[$file])) {
  127.                         [$expiresAt, $this->values[$id]] = self::$valuesCache[$file];
  128.                     } elseif (\is_array($expiresAt = include $file)) {
  129.                         if ($this->appendOnly) {
  130.                             self::$valuesCache[$file] = $expiresAt;
  131.                         }
  133.                         [$expiresAt, $this->values[$id]] = $expiresAt;
  134.                     } elseif ($now < $expiresAt) {
  135.                         $this->values[$id] = new LazyValue($file);
  136.                     }
  138.                     if ($now >= $expiresAt) {
  139.                         unset($this->values[$id], $missingIds[$k], self::$valuesCache[$file]);
  140.                     }
  141.                 } catch (\ErrorException $e) {
  142.                     unset($missingIds[$k]);
  143.                 }
  144.             }
  145.         } finally {
  146.             restore_error_handler();
  147.         }
  149.         $ids = $missingIds;
  150.         $missingIds = [];
  151.         goto begin;
  152.     }
  154.     /**
  155.      * {@inheritdoc}
  156.      */
  157.     protected function doHave($id)
  158.     {
  159.         if ($this->appendOnly && isset($this->values[$id])) {
  160.             return true;
  161.         }
  163.         set_error_handler($this->includeHandler);
  164.         try {
  165.             $file = $this->files[$id] ?? $this->files[$id] = $this->getFile($id);
  166.             $getExpiry = true;
  168.             if (isset(self::$valuesCache[$file])) {
  169.                 [$expiresAt, $value] = self::$valuesCache[$file];
  170.             } elseif (\is_array($expiresAt = include $file)) {
  171.                 if ($this->appendOnly) {
  172.                     self::$valuesCache[$file] = $expiresAt;
  173.                 }
  175.                 [$expiresAt, $value] = $expiresAt;
  176.             } elseif ($this->appendOnly) {
  177.                 $value = new LazyValue($file);
  178.             }
  179.         } catch (\ErrorException $e) {
  180.             return false;
  181.         } finally {
  182.             restore_error_handler();
  183.         }
  184.         if ($this->appendOnly) {
  185.             $now = 0;
  186.             $this->values[$id] = $value;
  187.         } else {
  188.             $now = time();
  189.         }
  191.         return $now < $expiresAt;
  192.     }
  194.     /**
  195.      * {@inheritdoc}
  196.      */
  197.     protected function doSave(array $values, int $lifetime)
  198.     {
  199.         $ok = true;
  200.         $expiry = $lifetime ? time() + $lifetime : 'PHP_INT_MAX';
  201.         $allowCompile = self::isSupported();
  203.         foreach ($values as $key => $value) {
  204.             unset($this->values[$key]);
  205.             $isStaticValue = true;
  206.             if (null === $value) {
  207.                 $value = "'N;'";
  208.             } elseif (\is_object($value) || \is_array($value)) {
  209.                 try {
  210.                     $value = VarExporter::export($value, $isStaticValue);
  211.                 } catch (\Exception $e) {
  212.                     throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, \is_object($value) ? \get_class($value) : 'array'), 0, $e);
  213.                 }
  214.             } elseif (\is_string($value)) {
  215.                 // Wrap "N;" in a closure to not confuse it with an encoded `null`
  216.                 if ('N;' === $value) {
  217.                     $isStaticValue = false;
  218.                 }
  219.                 $value = var_export($value, true);
  220.             } elseif (!is_scalar($value)) {
  221.                 throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, \gettype($value)));
  222.             } else {
  223.                 $value = var_export($value, true);
  224.             }
  226.             $encodedKey = rawurlencode($key);
  228.             if ($isStaticValue) {
  229.                 $value = "return [{$expiry}, {$value}];";
  230.             } elseif ($this->appendOnly) {
  231.                 $value = "return [{$expiry}, static function () { return {$value}; }];";
  232.             } else {
  233.                 // We cannot use a closure here because of https://bugs.php.net/76982
  234.                 $value = str_replace('\Symfony\Component\VarExporter\Internal\\', '', $value);
  235.                 $value = "namespace Symfony\Component\VarExporter\Internal;\n\nreturn \$getExpiry ? {$expiry} : {$value};";
  236.             }
  238.             $file = $this->files[$key] = $this->getFile($key, true);
  239.             // Since OPcache only compiles files older than the script execution start, set the file's mtime in the past
  240.             $ok = $this->write($file, "<?php //{$encodedKey}\n\n{$value}\n", self::$startTime - 10) && $ok;
  242.             if ($allowCompile) {
  243.                 @opcache_invalidate($file, true);
  244.                 @opcache_compile_file($file);
  245.             }
  246.             unset(self::$valuesCache[$file]);
  247.         }
  249.         if (!$ok && !is_writable($this->directory)) {
  250.             throw new CacheException(sprintf('Cache directory is not writable (%s).', $this->directory));
  251.         }
  253.         return $ok;
  254.     }
  256.     /**
  257.      * {@inheritdoc}
  258.      */
  259.     protected function doClear($namespace)
  260.     {
  261.         $this->values = [];
  263.         return $this->doCommonClear($namespace);
  264.     }
  266.     /**
  267.      * {@inheritdoc}
  268.      */
  269.     protected function doDelete(array $ids)
  270.     {
  271.         foreach ($ids as $id) {
  272.             unset($this->values[$id]);
  273.         }
  275.         return $this->doCommonDelete($ids);
  276.     }
  278.     protected function doUnlink($file)
  279.     {
  280.         unset(self::$valuesCache[$file]);
  282.         if (self::isSupported()) {
  283.             @opcache_invalidate($file, true);
  284.         }
  286.         return @unlink($file);
  287.     }
  289.     private function getFileKey(string $file): string
  290.     {
  291.         if (!$h = @fopen($file, 'r')) {
  292.             return '';
  293.         }
  295.         $encodedKey = substr(fgets($h), 8);
  296.         fclose($h);
  298.         return rawurldecode(rtrim($encodedKey));
  299.     }
  300. }
  302. /**
  303.  * @internal
  304.  */
  305. class LazyValue
  306. {
  307.     public $file;
  309.     public function __construct(string $file)
  310.     {
  311.         $this->file = $file;
  312.     }
  313. }