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

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\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 $includeHandler;
  33.     private $appendOnly;
  34.     private $values = [];
  35.     private $files = [];
  37.     private static $startTime;
  38.     private static $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 = 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 = self::$startTime ?? $_SERVER['REQUEST_TIME'] ?? time();
  61.         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));
  62.     }
  64.     /**
  65.      * @return bool
  66.      */
  67.     public function prune()
  68.     {
  69.         $time = time();
  70.         $pruned = true;
  71.         $getExpiry = true;
  73.         set_error_handler($this->includeHandler);
  74.         try {
  75.             foreach ($this->scanHashDir($this->directory) as $file) {
  76.                 try {
  77.                     if (\is_array($expiresAt = include $file)) {
  78.                         $expiresAt = $expiresAt[0];
  79.                     }
  80.                 } catch (\ErrorException $e) {
  81.                     $expiresAt = $time;
  82.                 }
  84.                 if ($time >= $expiresAt) {
  85.                     $pruned = $this->doUnlink($file) && !file_exists($file) && $pruned;
  86.                 }
  87.             }
  88.         } finally {
  89.             restore_error_handler();
  90.         }
  92.         return $pruned;
  93.     }
  95.     /**
  96.      * {@inheritdoc}
  97.      */
  98.     protected function doFetch(array $ids)
  99.     {
  100.         if ($this->appendOnly) {
  101.             $now = 0;
  102.             $missingIds = [];
  103.         } else {
  104.             $now = time();
  105.             $missingIds = $ids;
  106.             $ids = [];
  107.         }
  108.         $values = [];
  110.         begin:
  111.         $getExpiry = false;
  113.         foreach ($ids as $id) {
  114.             if (null === $value = $this->values[$id] ?? null) {
  115.                 $missingIds[] = $id;
  116.             } elseif ('N;' === $value) {
  117.                 $values[$id] = null;
  118.             } elseif (!\is_object($value)) {
  119.                 $values[$id] = $value;
  120.             } elseif (!$value instanceof LazyValue) {
  121.                 $values[$id] = $value();
  122.             } elseif (false === $values[$id] = include $value->file) {
  123.                 unset($values[$id], $this->values[$id]);
  124.                 $missingIds[] = $id;
  125.             }
  126.             if (!$this->appendOnly) {
  127.                 unset($this->values[$id]);
  128.             }
  129.         }
  131.         if (!$missingIds) {
  132.             return $values;
  133.         }
  135.         set_error_handler($this->includeHandler);
  136.         try {
  137.             $getExpiry = true;
  139.             foreach ($missingIds as $k => $id) {
  140.                 try {
  141.                     $file = $this->files[$id] ?? $this->files[$id] = $this->getFile($id);
  143.                     if (isset(self::$valuesCache[$file])) {
  144.                         [$expiresAt, $this->values[$id]] = self::$valuesCache[$file];
  145.                     } elseif (\is_array($expiresAt = include $file)) {
  146.                         if ($this->appendOnly) {
  147.                             self::$valuesCache[$file] = $expiresAt;
  148.                         }
  150.                         [$expiresAt, $this->values[$id]] = $expiresAt;
  151.                     } elseif ($now < $expiresAt) {
  152.                         $this->values[$id] = new LazyValue($file);
  153.                     }
  155.                     if ($now >= $expiresAt) {
  156.                         unset($this->values[$id], $missingIds[$k], self::$valuesCache[$file]);
  157.                     }
  158.                 } catch (\ErrorException $e) {
  159.                     unset($missingIds[$k]);
  160.                 }
  161.             }
  162.         } finally {
  163.             restore_error_handler();
  164.         }
  166.         $ids = $missingIds;
  167.         $missingIds = [];
  168.         goto begin;
  169.     }
  171.     /**
  172.      * {@inheritdoc}
  173.      */
  174.     protected function doHave(string $id)
  175.     {
  176.         if ($this->appendOnly && isset($this->values[$id])) {
  177.             return true;
  178.         }
  180.         set_error_handler($this->includeHandler);
  181.         try {
  182.             $file = $this->files[$id] ?? $this->files[$id] = $this->getFile($id);
  183.             $getExpiry = true;
  185.             if (isset(self::$valuesCache[$file])) {
  186.                 [$expiresAt, $value] = self::$valuesCache[$file];
  187.             } elseif (\is_array($expiresAt = include $file)) {
  188.                 if ($this->appendOnly) {
  189.                     self::$valuesCache[$file] = $expiresAt;
  190.                 }
  192.                 [$expiresAt, $value] = $expiresAt;
  193.             } elseif ($this->appendOnly) {
  194.                 $value = new LazyValue($file);
  195.             }
  196.         } catch (\ErrorException $e) {
  197.             return false;
  198.         } finally {
  199.             restore_error_handler();
  200.         }
  201.         if ($this->appendOnly) {
  202.             $now = 0;
  203.             $this->values[$id] = $value;
  204.         } else {
  205.             $now = time();
  206.         }
  208.         return $now < $expiresAt;
  209.     }
  211.     /**
  212.      * {@inheritdoc}
  213.      */
  214.     protected function doSave(array $values, int $lifetime)
  215.     {
  216.         $ok = true;
  217.         $expiry = $lifetime ? time() + $lifetime : 'PHP_INT_MAX';
  218.         $allowCompile = self::isSupported();
  220.         foreach ($values as $key => $value) {
  221.             unset($this->values[$key]);
  222.             $isStaticValue = true;
  223.             if (null === $value) {
  224.                 $value = "'N;'";
  225.             } elseif (\is_object($value) || \is_array($value)) {
  226.                 try {
  227.                     $value = VarExporter::export($value, $isStaticValue);
  228.                 } catch (\Exception $e) {
  229.                     throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, get_debug_type($value)), 0, $e);
  230.                 }
  231.             } elseif (\is_string($value)) {
  232.                 // Wrap "N;" in a closure to not confuse it with an encoded `null`
  233.                 if ('N;' === $value) {
  234.                     $isStaticValue = false;
  235.                 }
  236.                 $value = var_export($value, true);
  237.             } elseif (!\is_scalar($value)) {
  238.                 throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, get_debug_type($value)));
  239.             } else {
  240.                 $value = var_export($value, true);
  241.             }
  243.             $encodedKey = rawurlencode($key);
  245.             if ($isStaticValue) {
  246.                 $value = "return [{$expiry}, {$value}];";
  247.             } elseif ($this->appendOnly) {
  248.                 $value = "return [{$expiry}, static function () { return {$value}; }];";
  249.             } else {
  250.                 // We cannot use a closure here because of https://bugs.php.net/76982
  251.                 $value = str_replace('\Symfony\Component\VarExporter\Internal\\', '', $value);
  252.                 $value = "namespace Symfony\Component\VarExporter\Internal;\n\nreturn \$getExpiry ? {$expiry} : {$value};";
  253.             }
  255.             $file = $this->files[$key] = $this->getFile($key, true);
  256.             // Since OPcache only compiles files older than the script execution start, set the file's mtime in the past
  257.             $ok = $this->write($file, "<?php //{$encodedKey}\n\n{$value}\n", self::$startTime - 10) && $ok;
  259.             if ($allowCompile) {
  260.                 @opcache_invalidate($file, true);
  261.                 @opcache_compile_file($file);
  262.             }
  263.             unset(self::$valuesCache[$file]);
  264.         }
  266.         if (!$ok && !is_writable($this->directory)) {
  267.             throw new CacheException(sprintf('Cache directory is not writable (%s).', $this->directory));
  268.         }
  270.         return $ok;
  271.     }
  273.     /**
  274.      * {@inheritdoc}
  275.      */
  276.     protected function doClear(string $namespace)
  277.     {
  278.         $this->values = [];
  280.         return $this->doCommonClear($namespace);
  281.     }
  283.     /**
  284.      * {@inheritdoc}
  285.      */
  286.     protected function doDelete(array $ids)
  287.     {
  288.         foreach ($ids as $id) {
  289.             unset($this->values[$id]);
  290.         }
  292.         return $this->doCommonDelete($ids);
  293.     }
  295.     protected function doUnlink(string $file)
  296.     {
  297.         unset(self::$valuesCache[$file]);
  299.         if (self::isSupported()) {
  300.             @opcache_invalidate($file, true);
  301.         }
  303.         return @unlink($file);
  304.     }
  306.     private function getFileKey(string $file): string
  307.     {
  308.         if (!$h = @fopen($file, 'r')) {
  309.             return '';
  310.         }
  312.         $encodedKey = substr(fgets($h), 8);
  313.         fclose($h);
  315.         return rawurldecode(rtrim($encodedKey));
  316.     }
  317. }
  319. /**
  320.  * @internal
  321.  */
  322. class LazyValue
  323. {
  324.     public $file;
  326.     public function __construct(string $file)
  327.     {
  328.         $this->file = $file;
  329.     }
  330. }