vendor/symfony/cache/Traits/AbstractAdapterTrait.php line 228

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 Psr\Cache\CacheItemInterface;
  15. use Psr\Log\LoggerAwareTrait;
  16. use Symfony\Component\Cache\CacheItem;
  17. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  19. /**
  20. * @author Nicolas Grekas <p@tchwork.com>
  21. *
  22. * @internal
  23. */
  24. trait AbstractAdapterTrait
  25. {
  26. use LoggerAwareTrait;
  28. /**
  29. * @var \Closure needs to be set by class, signature is function(string <key>, mixed <value>, bool <isHit>)
  30. */
  31. private static $createCacheItem;
  33. /**
  34. * @var \Closure needs to be set by class, signature is function(array <deferred>, string <namespace>, array <&expiredIds>)
  35. */
  36. private static $mergeByLifetime;
  38. private $namespace = '';
  39. private $defaultLifetime;
  40. private $namespaceVersion = '';
  41. private $versioningIsEnabled = false;
  42. private $deferred = [];
  43. private $ids = [];
  45. /**
  46. * @var int|null The maximum length to enforce for identifiers or null when no limit applies
  47. */
  48. protected $maxIdLength;
  50. /**
  51. * Fetches several cache items.
  52. *
  53. * @param array $ids The cache identifiers to fetch
  54. *
  55. * @return array|\Traversable
  56. */
  57. abstract protected function doFetch(array $ids);
  59. /**
  60. * Confirms if the cache contains specified cache item.
  61. *
  62. * @param string $id The identifier for which to check existence
  63. *
  64. * @return bool
  65. */
  66. abstract protected function doHave(string $id);
  68. /**
  69. * Deletes all items in the pool.
  70. *
  71. * @param string $namespace The prefix used for all identifiers managed by this pool
  72. *
  73. * @return bool
  74. */
  75. abstract protected function doClear(string $namespace);
  77. /**
  78. * Removes multiple items from the pool.
  79. *
  80. * @param array $ids An array of identifiers that should be removed from the pool
  81. *
  82. * @return bool
  83. */
  84. abstract protected function doDelete(array $ids);
  86. /**
  87. * Persists several cache items immediately.
  88. *
  89. * @param array $values The values to cache, indexed by their cache identifier
  90. * @param int $lifetime The lifetime of the cached values, 0 for persisting until manual cleaning
  91. *
  92. * @return array|bool The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  93. */
  94. abstract protected function doSave(array $values, int $lifetime);
  96. /**
  97. * {@inheritdoc}
  98. *
  99. * @return bool
  100. */
  101. public function hasItem($key)
  102. {
  103. $id = $this->getId($key);
  105. if (isset($this->deferred[$key])) {
  106. $this->commit();
  107. }
  109. try {
  110. return $this->doHave($id);
  111. } catch (\Exception $e) {
  112. CacheItem::log($this->logger, 'Failed to check if key "{key}" is cached: '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  114. return false;
  115. }
  116. }
  118. /**
  119. * {@inheritdoc}
  120. *
  121. * @return bool
  122. */
  123. public function clear(string $prefix = '')
  124. {
  125. $this->deferred = [];
  126. if ($cleared = $this->versioningIsEnabled) {
  127. if ('' === $namespaceVersionToClear = $this->namespaceVersion) {
  128. foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  129. $namespaceVersionToClear = $v;
  130. }
  131. }
  132. $namespaceToClear = $this->namespace.$namespaceVersionToClear;
  133. $namespaceVersion = self::formatNamespaceVersion(mt_rand());
  134. try {
  135. $e = $this->doSave([static::NS_SEPARATOR.$this->namespace => $namespaceVersion], 0);
  136. } catch (\Exception $e) {
  137. }
  138. if (true !== $e && [] !== $e) {
  139. $cleared = false;
  140. $message = 'Failed to save the new namespace'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  141. CacheItem::log($this->logger, $message, ['exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  142. } else {
  143. $this->namespaceVersion = $namespaceVersion;
  144. $this->ids = [];
  145. }
  146. } elseif (preg_match('#[^-+.:_A-Za-z0-9]#', $prefix)) {
  147. CacheItem::log($this->logger, 'Failed to clear the cache: Namespace-prefix contains invalid characters.', ['cache-adapter' => get_debug_type($this)]);
  149. return false;
  150. } else {
  151. $namespaceToClear = $this->namespace.$prefix;
  152. }
  154. try {
  155. return $this->doClear($namespaceToClear) || $cleared;
  156. } catch (\Exception $e) {
  157. CacheItem::log($this->logger, 'Failed to clear the cache: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  159. return false;
  160. }
  161. }
  163. /**
  164. * {@inheritdoc}
  165. *
  166. * @return bool
  167. */
  168. public function deleteItem($key)
  169. {
  170. return $this->deleteItems([$key]);
  171. }
  173. /**
  174. * {@inheritdoc}
  175. *
  176. * @return bool
  177. */
  178. public function deleteItems(array $keys)
  179. {
  180. $ids = [];
  182. foreach ($keys as $key) {
  183. $ids[$key] = $this->getId($key);
  184. unset($this->deferred[$key]);
  185. }
  187. try {
  188. if ($this->doDelete($ids)) {
  189. return true;
  190. }
  191. } catch (\Exception $e) {
  192. }
  194. $ok = true;
  196. // When bulk-delete failed, retry each item individually
  197. foreach ($ids as $key => $id) {
  198. try {
  199. $e = null;
  200. if ($this->doDelete([$id])) {
  201. continue;
  202. }
  203. } catch (\Exception $e) {
  204. }
  205. $message = 'Failed to delete key "{key}"'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  206. CacheItem::log($this->logger, $message, ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  207. $ok = false;
  208. }
  210. return $ok;
  211. }
  213. /**
  214. * {@inheritdoc}
  215. */
  216. public function getItem($key)
  217. {
  218. $id = $this->getId($key);
  220. if (isset($this->deferred[$key])) {
  221. $this->commit();
  222. }
  224. $isHit = false;
  225. $value = null;
  227. try {
  228. foreach ($this->doFetch([$id]) as $value) {
  229. $isHit = true;
  230. }
  232. return (self::$createCacheItem)($key, $value, $isHit);
  233. } catch (\Exception $e) {
  234. CacheItem::log($this->logger, 'Failed to fetch key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  235. }
  237. return (self::$createCacheItem)($key, null, false);
  238. }
  240. /**
  241. * {@inheritdoc}
  242. */
  243. public function getItems(array $keys = [])
  244. {
  245. $ids = [];
  246. $commit = false;
  248. foreach ($keys as $key) {
  249. $ids[] = $this->getId($key);
  250. $commit = $commit || isset($this->deferred[$key]);
  251. }
  253. if ($commit) {
  254. $this->commit();
  255. }
  257. try {
  258. $items = $this->doFetch($ids);
  259. } catch (\Exception $e) {
  260. CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => $keys, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  261. $items = [];
  262. }
  263. $ids = array_combine($ids, $keys);
  265. return $this->generateItems($items, $ids);
  266. }
  268. /**
  269. * {@inheritdoc}
  270. *
  271. * @return bool
  272. */
  273. public function save(CacheItemInterface $item)
  274. {
  275. if (!$item instanceof CacheItem) {
  276. return false;
  277. }
  278. $this->deferred[$item->getKey()] = $item;
  280. return $this->commit();
  281. }
  283. /**
  284. * {@inheritdoc}
  285. *
  286. * @return bool
  287. */
  288. public function saveDeferred(CacheItemInterface $item)
  289. {
  290. if (!$item instanceof CacheItem) {
  291. return false;
  292. }
  293. $this->deferred[$item->getKey()] = $item;
  295. return true;
  296. }
  298. /**
  299. * Enables/disables versioning of items.
  300. *
  301. * When versioning is enabled, clearing the cache is atomic and doesn't require listing existing keys to proceed,
  302. * but old keys may need garbage collection and extra round-trips to the back-end are required.
  303. *
  304. * Calling this method also clears the memoized namespace version and thus forces a resynchronization of it.
  305. *
  306. * @return bool the previous state of versioning
  307. */
  308. public function enableVersioning(bool $enable = true)
  309. {
  310. $wasEnabled = $this->versioningIsEnabled;
  311. $this->versioningIsEnabled = $enable;
  312. $this->namespaceVersion = '';
  313. $this->ids = [];
  315. return $wasEnabled;
  316. }
  318. /**
  319. * {@inheritdoc}
  320. */
  321. public function reset()
  322. {
  323. if ($this->deferred) {
  324. $this->commit();
  325. }
  326. $this->namespaceVersion = '';
  327. $this->ids = [];
  328. }
  330. /**
  331. * @return array
  332. */
  333. public function __sleep()
  334. {
  335. throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  336. }
  338. public function __wakeup()
  339. {
  340. throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  341. }
  343. public function __destruct()
  344. {
  345. if ($this->deferred) {
  346. $this->commit();
  347. }
  348. }
  350. private function generateItems(iterable $items, array &$keys): \Generator
  351. {
  352. $f = self::$createCacheItem;
  354. try {
  355. foreach ($items as $id => $value) {
  356. if (!isset($keys[$id])) {
  357. throw new InvalidArgumentException(sprintf('Could not match value id "%s" to keys "%s".', $id, implode('", "', $keys)));
  358. }
  359. $key = $keys[$id];
  360. unset($keys[$id]);
  361. yield $key => $f($key, $value, true);
  362. }
  363. } catch (\Exception $e) {
  364. CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  365. }
  367. foreach ($keys as $key) {
  368. yield $key => $f($key, null, false);
  369. }
  370. }
  372. /**
  373. * @internal
  374. */
  375. protected function getId($key)
  376. {
  377. if ($this->versioningIsEnabled && '' === $this->namespaceVersion) {
  378. $this->ids = [];
  379. $this->namespaceVersion = '1'.static::NS_SEPARATOR;
  380. try {
  381. foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  382. $this->namespaceVersion = $v;
  383. }
  384. $e = true;
  385. if ('1'.static::NS_SEPARATOR === $this->namespaceVersion) {
  386. $this->namespaceVersion = self::formatNamespaceVersion(time());
  387. $e = $this->doSave([static::NS_SEPARATOR.$this->namespace => $this->namespaceVersion], 0);
  388. }
  389. } catch (\Exception $e) {
  390. }
  391. if (true !== $e && [] !== $e) {
  392. $message = 'Failed to save the new namespace'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  393. CacheItem::log($this->logger, $message, ['exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  394. }
  395. }
  397. if (\is_string($key) && isset($this->ids[$key])) {
  398. return $this->namespace.$this->namespaceVersion.$this->ids[$key];
  399. }
  400. \assert('' !== CacheItem::validateKey($key));
  401. $this->ids[$key] = $key;
  403. if (\count($this->ids) > 1000) {
  404. $this->ids = \array_slice($this->ids, 500, null, true); // stop memory leak if there are many keys
  405. }
  407. if (null === $this->maxIdLength) {
  408. return $this->namespace.$this->namespaceVersion.$key;
  409. }
  410. if (\strlen($id = $this->namespace.$this->namespaceVersion.$key) > $this->maxIdLength) {
  411. // Use MD5 to favor speed over security, which is not an issue here
  412. $this->ids[$key] = $id = substr_replace(base64_encode(hash('md5', $key, true)), static::NS_SEPARATOR, -(\strlen($this->namespaceVersion) + 2));
  413. $id = $this->namespace.$this->namespaceVersion.$id;
  414. }
  416. return $id;
  417. }
  419. /**
  420. * @internal
  421. */
  422. public static function handleUnserializeCallback(string $class)
  423. {
  424. throw new \DomainException('Class not found: '.$class);
  425. }
  427. private static function formatNamespaceVersion(int $value): string
  428. {
  429. return strtr(substr_replace(base64_encode(pack('V', $value)), static::NS_SEPARATOR, 5), '/', '_');
  430. }
  431. }