vendor/symfony/cache/Adapter/PhpFilesAdapter.php line 243

  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\Adapter;
  14. use Symfony\Component\Cache\Exception\CacheException;
  15. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  16. use Symfony\Component\Cache\PruneableInterface;
  17. use Symfony\Component\Cache\Traits\FilesystemCommonTrait;
  18. use Symfony\Component\VarExporter\VarExporter;
  20. /**
  21.  * @author Piotr Stankowski <git@trakos.pl>
  22.  * @author Nicolas Grekas <p@tchwork.com>
  23.  * @author Rob Frawley 2nd <rmf@src.run>
  24.  */
  25. class PhpFilesAdapter extends AbstractAdapter implements PruneableInterface
  26. {
  27.     use FilesystemCommonTrait {
  28.         doClear as private doCommonClear;
  29.         doDelete as private doCommonDelete;
  30.     }
  32.     private \Closure $includeHandler;
  33.     private bool $appendOnly;
  34.     private array $values = [];
  35.     private array $files = [];
  37.     private static int $startTime;
  38.     private static array $valuesCache = [];
  40.     /**
  41.      * @param $appendOnly Set to `true` to gain extra performance when the items stored in this pool never expire.
  42.      *                    Doing so is encouraged because it fits perfectly OPcache's memory model.
  43.      *
  44.      * @throws CacheException if OPcache is not enabled
  45.      */
  46.     public function __construct(string $namespace = '', int $defaultLifetime = 0, string $directory = null, bool $appendOnly = false)
  47.     {
  48.         $this->appendOnly = $appendOnly;
  49.         self::$startTime ??= $_SERVER['REQUEST_TIME'] ?? time();
  50.         parent::__construct('', $defaultLifetime);
  51.         $this->init($namespace, $directory);
  52.         $this->includeHandler = static function ($type, $msg, $file, $line) {
  53.             throw new \ErrorException($msg, 0, $type, $file, $line);
  54.         };
  55.     }
  57.     public static function isSupported()
  58.     {
  59.         self::$startTime ??= $_SERVER['REQUEST_TIME'] ?? time();
  61.         return \function_exists('opcache_invalidate') && filter_var(\ini_get('opcache.enable'), \FILTER_VALIDATE_BOOL) && (!\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) || filter_var(\ini_get('opcache.enable_cli'), \FILTER_VALIDATE_BOOL));
  62.     }
  64.     public function prune(): bool
  65.     {
  66.         $time = time();
  67.         $pruned = true;
  68.         $getExpiry = true;
  70.         set_error_handler($this->includeHandler);
  71.         try {
  72.             foreach ($this->scanHashDir($this->directory) as $file) {
  73.                 try {
  74.                     if (\is_array($expiresAt = include $file)) {
  75.                         $expiresAt = $expiresAt[0];
  76.                     }
  77.                 } catch (\ErrorException $e) {
  78.                     $expiresAt = $time;
  79.                 }
  81.                 if ($time >= $expiresAt) {
  82.                     $pruned = $this->doUnlink($file) && !file_exists($file) && $pruned;
  83.                 }
  84.             }
  85.         } finally {
  86.             restore_error_handler();
  87.         }
  89.         return $pruned;
  90.     }
  92.     protected function doFetch(array $ids): iterable
  93.     {
  94.         if ($this->appendOnly) {
  95.             $now = 0;
  96.             $missingIds = [];
  97.         } else {
  98.             $now = time();
  99.             $missingIds = $ids;
  100.             $ids = [];
  101.         }
  102.         $values = [];
  104.         begin:
  105.         $getExpiry = false;
  107.         foreach ($ids as $id) {
  108.             if (null === $value = $this->values[$id] ?? null) {
  109.                 $missingIds[] = $id;
  110.             } elseif ('N;' === $value) {
  111.                 $values[$id] = null;
  112.             } elseif (!\is_object($value)) {
  113.                 $values[$id] = $value;
  114.             } elseif (!$value instanceof LazyValue) {
  115.                 $values[$id] = $value();
  116.             } elseif (false === $values[$id] = include $value->file) {
  117.                 unset($values[$id], $this->values[$id]);
  118.                 $missingIds[] = $id;
  119.             }
  120.             if (!$this->appendOnly) {
  121.                 unset($this->values[$id]);
  122.             }
  123.         }
  125.         if (!$missingIds) {
  126.             return $values;
  127.         }
  129.         set_error_handler($this->includeHandler);
  130.         try {
  131.             $getExpiry = true;
  133.             foreach ($missingIds as $k => $id) {
  134.                 try {
  135.                     $file = $this->files[$id] ??= $this->getFile($id);
  137.                     if (isset(self::$valuesCache[$file])) {
  138.                         [$expiresAt, $this->values[$id]] = self::$valuesCache[$file];
  139.                     } elseif (\is_array($expiresAt = include $file)) {
  140.                         if ($this->appendOnly) {
  141.                             self::$valuesCache[$file] = $expiresAt;
  142.                         }
  144.                         [$expiresAt, $this->values[$id]] = $expiresAt;
  145.                     } elseif ($now < $expiresAt) {
  146.                         $this->values[$id] = new LazyValue($file);
  147.                     }
  149.                     if ($now >= $expiresAt) {
  150.                         unset($this->values[$id], $missingIds[$k], self::$valuesCache[$file]);
  151.                     }
  152.                 } catch (\ErrorException $e) {
  153.                     unset($missingIds[$k]);
  154.                 }
  155.             }
  156.         } finally {
  157.             restore_error_handler();
  158.         }
  160.         $ids = $missingIds;
  161.         $missingIds = [];
  162.         goto begin;
  163.     }
  165.     protected function doHave(string $id): bool
  166.     {
  167.         if ($this->appendOnly && isset($this->values[$id])) {
  168.             return true;
  169.         }
  171.         set_error_handler($this->includeHandler);
  172.         try {
  173.             $file = $this->files[$id] ??= $this->getFile($id);
  174.             $getExpiry = true;
  176.             if (isset(self::$valuesCache[$file])) {
  177.                 [$expiresAt, $value] = self::$valuesCache[$file];
  178.             } elseif (\is_array($expiresAt = include $file)) {
  179.                 if ($this->appendOnly) {
  180.                     self::$valuesCache[$file] = $expiresAt;
  181.                 }
  183.                 [$expiresAt, $value] = $expiresAt;
  184.             } elseif ($this->appendOnly) {
  185.                 $value = new LazyValue($file);
  186.             }
  187.         } catch (\ErrorException) {
  188.             return false;
  189.         } finally {
  190.             restore_error_handler();
  191.         }
  192.         if ($this->appendOnly) {
  193.             $now = 0;
  194.             $this->values[$id] = $value;
  195.         } else {
  196.             $now = time();
  197.         }
  199.         return $now < $expiresAt;
  200.     }
  202.     protected function doSave(array $values, int $lifetime): array|bool
  203.     {
  204.         $ok = true;
  205.         $expiry = $lifetime ? time() + $lifetime : 'PHP_INT_MAX';
  206.         $allowCompile = self::isSupported();
  208.         foreach ($values as $key => $value) {
  209.             unset($this->values[$key]);
  210.             $isStaticValue = true;
  211.             if (null === $value) {
  212.                 $value = "'N;'";
  213.             } elseif (\is_object($value) || \is_array($value)) {
  214.                 try {
  215.                     $value = VarExporter::export($value, $isStaticValue);
  216.                 } catch (\Exception $e) {
  217.                     throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, get_debug_type($value)), 0, $e);
  218.                 }
  219.             } elseif (\is_string($value)) {
  220.                 // Wrap "N;" in a closure to not confuse it with an encoded `null`
  221.                 if ('N;' === $value) {
  222.                     $isStaticValue = false;
  223.                 }
  224.                 $value = var_export($value, true);
  225.             } elseif (!\is_scalar($value)) {
  226.                 throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, get_debug_type($value)));
  227.             } else {
  228.                 $value = var_export($value, true);
  229.             }
  231.             $encodedKey = rawurlencode($key);
  233.             if ($isStaticValue) {
  234.                 $value = "return [{$expiry}, {$value}];";
  235.             } elseif ($this->appendOnly) {
  236.                 $value = "return [{$expiry}, static function () { return {$value}; }];";
  237.             } else {
  238.                 // We cannot use a closure here because of https://bugs.php.net/76982
  239.                 $value = str_replace('\Symfony\Component\VarExporter\Internal\\', '', $value);
  240.                 $value = "namespace Symfony\Component\VarExporter\Internal;\n\nreturn \$getExpiry ? {$expiry} : {$value};";
  241.             }
  243.             $file = $this->files[$key] = $this->getFile($key, true);
  244.             // Since OPcache only compiles files older than the script execution start, set the file's mtime in the past
  245.             $ok = $this->write($file, "<?php //{$encodedKey}\n\n{$value}\n", self::$startTime - 10) && $ok;
  247.             if ($allowCompile) {
  248.                 @opcache_invalidate($file, true);
  249.                 @opcache_compile_file($file);
  250.             }
  251.             unset(self::$valuesCache[$file]);
  252.         }
  254.         if (!$ok && !is_writable($this->directory)) {
  255.             throw new CacheException(sprintf('Cache directory is not writable (%s).', $this->directory));
  256.         }
  258.         return $ok;
  259.     }
  261.     protected function doClear(string $namespace): bool
  262.     {
  263.         $this->values = [];
  265.         return $this->doCommonClear($namespace);
  266.     }
  268.     protected function doDelete(array $ids): bool
  269.     {
  270.         foreach ($ids as $id) {
  271.             unset($this->values[$id]);
  272.         }
  274.         return $this->doCommonDelete($ids);
  275.     }
  277.     protected function doUnlink(string $file)
  278.     {
  279.         unset(self::$valuesCache[$file]);
  281.         if (self::isSupported()) {
  282.             @opcache_invalidate($file, true);
  283.         }
  285.         return @unlink($file);
  286.     }
  288.     private function getFileKey(string $file): string
  289.     {
  290.         if (!$h = @fopen($file, 'r')) {
  291.             return '';
  292.         }
  294.         $encodedKey = substr(fgets($h), 8);
  295.         fclose($h);
  297.         return rawurldecode(rtrim($encodedKey));
  298.     }
  299. }
  301. /**
  302.  * @internal
  303.  */
  304. class LazyValue
  305. {
  306.     public string $file;
  308.     public function __construct(string $file)
  309.     {
  310.         $this->file = $file;
  311.     }
  312. }