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

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\Cache\CacheItemInterface;
  15. use Psr\Log\LoggerAwareInterface;
  16. use Psr\Log\LoggerInterface;
  17. use Psr\Log\NullLogger;
  18. use Symfony\Component\Cache\CacheItem;
  19. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  20. use Symfony\Component\Cache\ResettableInterface;
  21. use Symfony\Component\Cache\Traits\AbstractTrait;
  22. use Symfony\Component\Cache\Traits\ContractsTrait;
  23. use Symfony\Contracts\Cache\CacheInterface;
  25. /**
  26.  * @author Nicolas Grekas <p@tchwork.com>
  27.  */
  28. abstract class AbstractAdapter implements AdapterInterface, CacheInterface, LoggerAwareInterface, ResettableInterface
  29. {
  30.     use AbstractTrait;
  31.     use ContractsTrait;
  33.     private static $apcuSupported;
  34.     private static $phpFilesSupported;
  36.     private $createCacheItem;
  37.     private $mergeByLifetime;
  39.     protected function __construct(string $namespace = '', int $defaultLifetime = 0)
  40.     {
  41.         $this->namespace = '' === $namespace ? '' : CacheItem::validateKey($namespace).':';
  42.         if (null !== $this->maxIdLength && \strlen($namespace) > $this->maxIdLength - 24) {
  43.             throw new InvalidArgumentException(sprintf('Namespace must be %d chars max, %d given ("%s")', $this->maxIdLength - 24, \strlen($namespace), $namespace));
  44.         }
  45.         $this->createCacheItem = \Closure::bind(
  46.             function ($key, $value, $isHit) use ($defaultLifetime) {
  47.                 $item = new CacheItem();
  48.                 $item->key = $key;
  49.                 $item->value = $v = $value;
  50.                 $item->isHit = $isHit;
  51.                 $item->defaultLifetime = $defaultLifetime;
  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 = \key($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.         $getId = \Closure::fromCallable(array($this, 'getId'));
  68.         $this->mergeByLifetime = \Closure::bind(
  69.             function ($deferred, $namespace, &$expiredIds) use ($getId) {
  70.                 $byLifetime = array();
  71.                 $now = microtime(true);
  72.                 $expiredIds = array();
  74.                 foreach ($deferred as $key => $item) {
  75.                     $key = (string) $key;
  76.                     if (null === $item->expiry) {
  77.                         $ttl = 0 < $item->defaultLifetime ? $item->defaultLifetime : 0;
  78.                     } elseif (0 >= $ttl = (int) ($item->expiry - $now)) {
  79.                         $expiredIds[] = $getId($key);
  80.                         continue;
  81.                     }
  82.                     if (isset(($metadata = $item->newMetadata)[CacheItem::METADATA_TAGS])) {
  83.                         unset($metadata[CacheItem::METADATA_TAGS]);
  84.                     }
  85.                     // For compactness, expiry and creation duration are packed in the key of an array, using magic numbers as separators
  86.                     $byLifetime[$ttl][$getId($key)] = $metadata ? array("\x9D".pack('VN', (int) $metadata[CacheItem::METADATA_EXPIRY] - CacheItem::METADATA_EXPIRY_OFFSET, $metadata[CacheItem::METADATA_CTIME])."\x5F" => $item->value) : $item->value;
  87.                 }
  89.                 return $byLifetime;
  90.             },
  91.             null,
  92.             CacheItem::class
  93.         );
  94.     }
  96.     /**
  97.      * Returns an ApcuAdapter if supported, a PhpFilesAdapter otherwise.
  98.      *
  99.      * Using ApcuAdapter makes system caches compatible with read-only filesystems.
  100.      *
  101.      * @param string               $namespace
  102.      * @param int                  $defaultLifetime
  103.      * @param string               $version
  104.      * @param string               $directory
  105.      * @param LoggerInterface|null $logger
  106.      *
  107.      * @return AdapterInterface
  108.      */
  109.     public static function createSystemCache($namespace, $defaultLifetime, $version, $directory, LoggerInterface $logger = null)
  110.     {
  111.         if (null === self::$apcuSupported) {
  112.             self::$apcuSupported = ApcuAdapter::isSupported();
  113.         }
  115.         if (!self::$apcuSupported) {
  116.             $opcache = new PhpFilesAdapter($namespace, $defaultLifetime, $directory, true);
  117.             if (null !== $logger) {
  118.                 $opcache->setLogger($logger);
  119.             }
  121.             return $opcache;
  122.         }
  124.         $apcu = new ApcuAdapter($namespace, (int) $defaultLifetime / 5, $version);
  125.         if ('cli' === \PHP_SAPI && !filter_var(ini_get('apc.enable_cli'), FILTER_VALIDATE_BOOLEAN)) {
  126.             $apcu->setLogger(new NullLogger());
  127.         } elseif (null !== $logger) {
  128.             $apcu->setLogger($logger);
  129.         }
  131.         return $apcu;
  132.     }
  134.     public static function createConnection($dsn, array $options = array())
  135.     {
  136.         if (!\is_string($dsn)) {
  137.             throw new InvalidArgumentException(sprintf('The %s() method expect argument #1 to be string, %s given.', __METHOD__, \gettype($dsn)));
  138.         }
  139.         if (0 === strpos($dsn, 'redis:')) {
  140.             return RedisAdapter::createConnection($dsn, $options);
  141.         }
  142.         if (0 === strpos($dsn, 'memcached:')) {
  143.             return MemcachedAdapter::createConnection($dsn, $options);
  144.         }
  146.         throw new InvalidArgumentException(sprintf('Unsupported DSN: %s.', $dsn));
  147.     }
  149.     /**
  150.      * {@inheritdoc}
  151.      */
  152.     public function getItem($key)
  153.     {
  154.         if ($this->deferred) {
  155.             $this->commit();
  156.         }
  157.         $id = $this->getId($key);
  159.         $f = $this->createCacheItem;
  160.         $isHit = false;
  161.         $value = null;
  163.         try {
  164.             foreach ($this->doFetch(array($id)) as $value) {
  165.                 $isHit = true;
  166.             }
  167.         } catch (\Exception $e) {
  168.             CacheItem::log($this->logger, 'Failed to fetch key "{key}"', array('key' => $key, 'exception' => $e));
  169.         }
  171.         return $f($key, $value, $isHit);
  172.     }
  174.     /**
  175.      * {@inheritdoc}
  176.      */
  177.     public function getItems(array $keys = array())
  178.     {
  179.         if ($this->deferred) {
  180.             $this->commit();
  181.         }
  182.         $ids = array();
  184.         foreach ($keys as $key) {
  185.             $ids[] = $this->getId($key);
  186.         }
  187.         try {
  188.             $items = $this->doFetch($ids);
  189.         } catch (\Exception $e) {
  190.             CacheItem::log($this->logger, 'Failed to fetch requested items', array('keys' => $keys, 'exception' => $e));
  191.             $items = array();
  192.         }
  193.         $ids = array_combine($ids, $keys);
  195.         return $this->generateItems($items, $ids);
  196.     }
  198.     /**
  199.      * {@inheritdoc}
  200.      */
  201.     public function save(CacheItemInterface $item)
  202.     {
  203.         if (!$item instanceof CacheItem) {
  204.             return false;
  205.         }
  206.         $this->deferred[$item->getKey()] = $item;
  208.         return $this->commit();
  209.     }
  211.     /**
  212.      * {@inheritdoc}
  213.      */
  214.     public function saveDeferred(CacheItemInterface $item)
  215.     {
  216.         if (!$item instanceof CacheItem) {
  217.             return false;
  218.         }
  219.         $this->deferred[$item->getKey()] = $item;
  221.         return true;
  222.     }
  224.     /**
  225.      * {@inheritdoc}
  226.      */
  227.     public function commit()
  228.     {
  229.         $ok = true;
  230.         $byLifetime = $this->mergeByLifetime;
  231.         $byLifetime = $byLifetime($this->deferred, $this->namespace, $expiredIds);
  232.         $retry = $this->deferred = array();
  234.         if ($expiredIds) {
  235.             $this->doDelete($expiredIds);
  236.         }
  237.         foreach ($byLifetime as $lifetime => $values) {
  238.             try {
  239.                 $e = $this->doSave($values, $lifetime);
  240.             } catch (\Exception $e) {
  241.             }
  242.             if (true === $e || array() === $e) {
  243.                 continue;
  244.             }
  245.             if (\is_array($e) || 1 === \count($values)) {
  246.                 foreach (\is_array($e) ? $e : array_keys($values) as $id) {
  247.                     $ok = false;
  248.                     $v = $values[$id];
  249.                     $type = \is_object($v) ? \get_class($v) : \gettype($v);
  250.                     CacheItem::log($this->logger, 'Failed to save key "{key}" ({type})', array('key' => substr($id, \strlen($this->namespace)), 'type' => $type, 'exception' => $e instanceof \Exception ? $e : null));
  251.                 }
  252.             } else {
  253.                 foreach ($values as $id => $v) {
  254.                     $retry[$lifetime][] = $id;
  255.                 }
  256.             }
  257.         }
  259.         // When bulk-save failed, retry each item individually
  260.         foreach ($retry as $lifetime => $ids) {
  261.             foreach ($ids as $id) {
  262.                 try {
  263.                     $v = $byLifetime[$lifetime][$id];
  264.                     $e = $this->doSave(array($id => $v), $lifetime);
  265.                 } catch (\Exception $e) {
  266.                 }
  267.                 if (true === $e || array() === $e) {
  268.                     continue;
  269.                 }
  270.                 $ok = false;
  271.                 $type = \is_object($v) ? \get_class($v) : \gettype($v);
  272.                 CacheItem::log($this->logger, 'Failed to save key "{key}" ({type})', array('key' => substr($id, \strlen($this->namespace)), 'type' => $type, 'exception' => $e instanceof \Exception ? $e : null));
  273.             }
  274.         }
  276.         return $ok;
  277.     }
  279.     public function __destruct()
  280.     {
  281.         if ($this->deferred) {
  282.             $this->commit();
  283.         }
  284.     }
  286.     private function generateItems($items, &$keys)
  287.     {
  288.         $f = $this->createCacheItem;
  290.         try {
  291.             foreach ($items as $id => $value) {
  292.                 if (!isset($keys[$id])) {
  293.                     $id = key($keys);
  294.                 }
  295.                 $key = $keys[$id];
  296.                 unset($keys[$id]);
  297.                 yield $key => $f($key, $value, true);
  298.             }
  299.         } catch (\Exception $e) {
  300.             CacheItem::log($this->logger, 'Failed to fetch requested items', array('keys' => array_values($keys), 'exception' => $e));
  301.         }
  303.         foreach ($keys as $key) {
  304.             yield $key => $f($key, null, false);
  305.         }
  306.     }
  307. }