vendor/symfony/cache/Adapter/AbstractAdapter.php line 167

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 Psr\Log\LoggerAwareInterface;
  15. use Psr\Log\LoggerInterface;
  16. use Symfony\Component\Cache\CacheItem;
  17. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  18. use Symfony\Component\Cache\ResettableInterface;
  19. use Symfony\Component\Cache\Traits\AbstractAdapterTrait;
  20. use Symfony\Component\Cache\Traits\ContractsTrait;
  21. use Symfony\Contracts\Cache\CacheInterface;
  23. /**
  24.  * @author Nicolas Grekas <p@tchwork.com>
  25.  */
  26. abstract class AbstractAdapter implements AdapterInterface, CacheInterface, LoggerAwareInterface, ResettableInterface
  27. {
  28.     use AbstractAdapterTrait;
  29.     use ContractsTrait;
  31.     /**
  32.      * @internal
  33.      */
  34.     protected const NS_SEPARATOR = ':';
  36.     private static $apcuSupported;
  37.     private static $phpFilesSupported;
  39.     protected function __construct(string $namespace = '', int $defaultLifetime = 0)
  40.     {
  41.         $this->namespace = '' === $namespace ? '' : CacheItem::validateKey($namespace).static::NS_SEPARATOR;
  42.         $this->defaultLifetime = $defaultLifetime;
  43.         if (null !== $this->maxIdLength && \strlen($namespace) > $this->maxIdLength - 24) {
  44.             throw new InvalidArgumentException(sprintf('Namespace must be %d chars max, %d given ("%s").', $this->maxIdLength - 24, \strlen($namespace), $namespace));
  45.         }
  46.         self::$createCacheItem ?? self::$createCacheItem = \Closure::bind(
  47.             static function ($key, $value, $isHit) {
  48.                 $item = new CacheItem();
  49.                 $item->key = $key;
  50.                 $item->value = $v = $value;
  51.                 $item->isHit = $isHit;
  52.                 // Detect wrapped values that encode for their expiry and creation duration
  53.                 // For compactness, these values are packed in the key of an array using
  54.                 // magic numbers in the form 9D-..-..-..-..-00-..-..-..-5F
  55.                 if (\is_array($v) && 1 === \count($v) && 10 === \strlen($k = (string) array_key_first($v)) && "\x9D" === $k[0] && "\0" === $k[5] && "\x5F" === $k[9]) {
  56.                     $item->value = $v[$k];
  57.                     $v = unpack('Ve/Nc', substr($k, 1, -1));
  58.                     $item->metadata[CacheItem::METADATA_EXPIRY] = $v['e'] + CacheItem::METADATA_EXPIRY_OFFSET;
  59.                     $item->metadata[CacheItem::METADATA_CTIME] = $v['c'];
  60.                 }
  62.                 return $item;
  63.             },
  64.             null,
  65.             CacheItem::class
  66.         );
  67.         self::$mergeByLifetime ?? self::$mergeByLifetime = \Closure::bind(
  68.             static function ($deferred, $namespace, &$expiredIds, $getId, $defaultLifetime) {
  69.                 $byLifetime = [];
  70.                 $now = microtime(true);
  71.                 $expiredIds = [];
  73.                 foreach ($deferred as $key => $item) {
  74.                     $key = (string) $key;
  75.                     if (null === $item->expiry) {
  76.                         $ttl = 0 < $defaultLifetime ? $defaultLifetime : 0;
  77.                     } elseif (!$item->expiry) {
  78.                         $ttl = 0;
  79.                     } elseif (0 >= $ttl = (int) (0.1 + $item->expiry - $now)) {
  80.                         $expiredIds[] = $getId($key);
  81.                         continue;
  82.                     }
  83.                     if (isset(($metadata = $item->newMetadata)[CacheItem::METADATA_TAGS])) {
  84.                         unset($metadata[CacheItem::METADATA_TAGS]);
  85.                     }
  86.                     // For compactness, expiry and creation duration are packed in the key of an array, using magic numbers as separators
  87.                     $byLifetime[$ttl][$getId($key)] = $metadata ? ["\x9D".pack('VN', (int) (0.1 + $metadata[self::METADATA_EXPIRY] - self::METADATA_EXPIRY_OFFSET), $metadata[self::METADATA_CTIME])."\x5F" => $item->value] : $item->value;
  88.                 }
  90.                 return $byLifetime;
  91.             },
  92.             null,
  93.             CacheItem::class
  94.         );
  95.     }
  97.     /**
  98.      * Returns the best possible adapter that your runtime supports.
  99.      *
  100.      * Using ApcuAdapter makes system caches compatible with read-only filesystems.
  101.      *
  102.      * @return AdapterInterface
  103.      */
  104.     public static function createSystemCache(string $namespace, int $defaultLifetime, string $version, string $directory, ?LoggerInterface $logger = null)
  105.     {
  106.         $opcache = new PhpFilesAdapter($namespace, $defaultLifetime, $directory, true);
  107.         if (null !== $logger) {
  108.             $opcache->setLogger($logger);
  109.         }
  111.         if (!self::$apcuSupported = self::$apcuSupported ?? ApcuAdapter::isSupported()) {
  112.             return $opcache;
  113.         }
  115.         if (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) && !filter_var(\ini_get('apc.enable_cli'), \FILTER_VALIDATE_BOOLEAN)) {
  116.             return $opcache;
  117.         }
  119.         $apcu = new ApcuAdapter($namespace, intdiv($defaultLifetime, 5), $version);
  120.         if (null !== $logger) {
  121.             $apcu->setLogger($logger);
  122.         }
  124.         return new ChainAdapter([$apcu, $opcache]);
  125.     }
  127.     public static function createConnection(string $dsn, array $options = [])
  128.     {
  129.         if (str_starts_with($dsn, 'redis:') || str_starts_with($dsn, 'rediss:')) {
  130.             return RedisAdapter::createConnection($dsn, $options);
  131.         }
  132.         if (str_starts_with($dsn, 'memcached:')) {
  133.             return MemcachedAdapter::createConnection($dsn, $options);
  134.         }
  135.         if (0 === strpos($dsn, 'couchbase:')) {
  136.             if (CouchbaseBucketAdapter::isSupported()) {
  137.                 return CouchbaseBucketAdapter::createConnection($dsn, $options);
  138.             }
  140.             return CouchbaseCollectionAdapter::createConnection($dsn, $options);
  141.         }
  143.         throw new InvalidArgumentException('Unsupported DSN: it does not start with "redis[s]:", "memcached:" nor "couchbase:".');
  144.     }
  146.     /**
  147.      * {@inheritdoc}
  148.      *
  149.      * @return bool
  150.      */
  151.     public function commit()
  152.     {
  153.         $ok = true;
  154.         $byLifetime = (self::$mergeByLifetime)($this->deferred, $this->namespace, $expiredIds, \Closure::fromCallable([$this, 'getId']), $this->defaultLifetime);
  155.         $retry = $this->deferred = [];
  157.         if ($expiredIds) {
  158.             try {
  159.                 $this->doDelete($expiredIds);
  160.             } catch (\Exception $e) {
  161.                 $ok = false;
  162.                 CacheItem::log($this->logger, 'Failed to delete expired items: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  163.             }
  164.         }
  165.         foreach ($byLifetime as $lifetime => $values) {
  166.             try {
  167.                 $e = $this->doSave($values, $lifetime);
  168.             } catch (\Exception $e) {
  169.             }
  170.             if (true === $e || [] === $e) {
  171.                 continue;
  172.             }
  173.             if (\is_array($e) || 1 === \count($values)) {
  174.                 foreach (\is_array($e) ? $e : array_keys($values) as $id) {
  175.                     $ok = false;
  176.                     $v = $values[$id];
  177.                     $type = get_debug_type($v);
  178.                     $message = sprintf('Failed to save key "{key}" of type %s%s', $type, $e instanceof \Exception ? ': '.$e->getMessage() : '.');
  179.                     CacheItem::log($this->logger, $message, ['key' => substr($id, \strlen($this->namespace)), 'exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  180.                 }
  181.             } else {
  182.                 foreach ($values as $id => $v) {
  183.                     $retry[$lifetime][] = $id;
  184.                 }
  185.             }
  186.         }
  188.         // When bulk-save failed, retry each item individually
  189.         foreach ($retry as $lifetime => $ids) {
  190.             foreach ($ids as $id) {
  191.                 try {
  192.                     $v = $byLifetime[$lifetime][$id];
  193.                     $e = $this->doSave([$id => $v], $lifetime);
  194.                 } catch (\Exception $e) {
  195.                 }
  196.                 if (true === $e || [] === $e) {
  197.                     continue;
  198.                 }
  199.                 $ok = false;
  200.                 $type = get_debug_type($v);
  201.                 $message = sprintf('Failed to save key "{key}" of type %s%s', $type, $e instanceof \Exception ? ': '.$e->getMessage() : '.');
  202.                 CacheItem::log($this->logger, $message, ['key' => substr($id, \strlen($this->namespace)), 'exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  203.             }
  204.         }
  206.         return $ok;
  207.     }
  208. }