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

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. * needs to be set by class, signature is function(string <key>, mixed <value>, bool <isHit>).
  30. */
  31. private static \Closure $createCacheItem;
  33. /**
  34. * needs to be set by class, signature is function(array <deferred>, string <namespace>, array <&expiredIds>).
  35. */
  36. private static \Closure $mergeByLifetime;
  38. private string $namespace = '';
  39. private int $defaultLifetime;
  40. private string $namespaceVersion = '';
  41. private bool $versioningIsEnabled = false;
  42. private array $deferred = [];
  43. private array $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. abstract protected function doFetch(array $ids): iterable;
  57. /**
  58. * Confirms if the cache contains specified cache item.
  59. *
  60. * @param string $id The identifier for which to check existence
  61. */
  62. abstract protected function doHave(string $id): bool;
  64. /**
  65. * Deletes all items in the pool.
  66. *
  67. * @param string $namespace The prefix used for all identifiers managed by this pool
  68. */
  69. abstract protected function doClear(string $namespace): bool;
  71. /**
  72. * Removes multiple items from the pool.
  73. *
  74. * @param array $ids An array of identifiers that should be removed from the pool
  75. */
  76. abstract protected function doDelete(array $ids): bool;
  78. /**
  79. * Persists several cache items immediately.
  80. *
  81. * @param array $values The values to cache, indexed by their cache identifier
  82. * @param int $lifetime The lifetime of the cached values, 0 for persisting until manual cleaning
  83. *
  84. * @return array|bool The identifiers that failed to be cached or a boolean stating if caching succeeded or not
  85. */
  86. abstract protected function doSave(array $values, int $lifetime): array|bool;
  88. public function hasItem(mixed $key): bool
  89. {
  90. $id = $this->getId($key);
  92. if (isset($this->deferred[$key])) {
  93. $this->commit();
  94. }
  96. try {
  97. return $this->doHave($id);
  98. } catch (\Exception $e) {
  99. CacheItem::log($this->logger, 'Failed to check if key "{key}" is cached: '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  101. return false;
  102. }
  103. }
  105. public function clear(string $prefix = ''): bool
  106. {
  107. $this->deferred = [];
  108. if ($cleared = $this->versioningIsEnabled) {
  109. if ('' === $namespaceVersionToClear = $this->namespaceVersion) {
  110. foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  111. $namespaceVersionToClear = $v;
  112. }
  113. }
  114. $namespaceToClear = $this->namespace.$namespaceVersionToClear;
  115. $namespaceVersion = self::formatNamespaceVersion(mt_rand());
  116. try {
  117. $e = $this->doSave([static::NS_SEPARATOR.$this->namespace => $namespaceVersion], 0);
  118. } catch (\Exception $e) {
  119. }
  120. if (true !== $e && [] !== $e) {
  121. $cleared = false;
  122. $message = 'Failed to save the new namespace'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  123. CacheItem::log($this->logger, $message, ['exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  124. } else {
  125. $this->namespaceVersion = $namespaceVersion;
  126. $this->ids = [];
  127. }
  128. } elseif (preg_match('#[^-+.:_A-Za-z0-9]#', $prefix)) {
  129. CacheItem::log($this->logger, 'Failed to clear the cache: Namespace-prefix contains invalid characters.', ['cache-adapter' => get_debug_type($this)]);
  131. return false;
  132. } else {
  133. $namespaceToClear = $this->namespace.$prefix;
  134. }
  136. try {
  137. return $this->doClear($namespaceToClear) || $cleared;
  138. } catch (\Exception $e) {
  139. CacheItem::log($this->logger, 'Failed to clear the cache: '.$e->getMessage(), ['exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  141. return false;
  142. }
  143. }
  145. public function deleteItem(mixed $key): bool
  146. {
  147. return $this->deleteItems([$key]);
  148. }
  150. public function deleteItems(array $keys): bool
  151. {
  152. $ids = [];
  154. foreach ($keys as $key) {
  155. $ids[$key] = $this->getId($key);
  156. unset($this->deferred[$key]);
  157. }
  159. try {
  160. if ($this->doDelete($ids)) {
  161. return true;
  162. }
  163. } catch (\Exception) {
  164. }
  166. $ok = true;
  168. // When bulk-delete failed, retry each item individually
  169. foreach ($ids as $key => $id) {
  170. try {
  171. $e = null;
  172. if ($this->doDelete([$id])) {
  173. continue;
  174. }
  175. } catch (\Exception $e) {
  176. }
  177. $message = 'Failed to delete key "{key}"'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  178. CacheItem::log($this->logger, $message, ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  179. $ok = false;
  180. }
  182. return $ok;
  183. }
  185. public function getItem(mixed $key): CacheItem
  186. {
  187. $id = $this->getId($key);
  189. if (isset($this->deferred[$key])) {
  190. $this->commit();
  191. }
  193. $isHit = false;
  194. $value = null;
  196. try {
  197. foreach ($this->doFetch([$id]) as $value) {
  198. $isHit = true;
  199. }
  201. return (self::$createCacheItem)($key, $value, $isHit);
  202. } catch (\Exception $e) {
  203. CacheItem::log($this->logger, 'Failed to fetch key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  204. }
  206. return (self::$createCacheItem)($key, null, false);
  207. }
  209. public function getItems(array $keys = []): iterable
  210. {
  211. $ids = [];
  212. $commit = false;
  214. foreach ($keys as $key) {
  215. $ids[] = $this->getId($key);
  216. $commit = $commit || isset($this->deferred[$key]);
  217. }
  219. if ($commit) {
  220. $this->commit();
  221. }
  223. try {
  224. $items = $this->doFetch($ids);
  225. } catch (\Exception $e) {
  226. CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => $keys, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  227. $items = [];
  228. }
  229. $ids = array_combine($ids, $keys);
  231. return $this->generateItems($items, $ids);
  232. }
  234. public function save(CacheItemInterface $item): bool
  235. {
  236. if (!$item instanceof CacheItem) {
  237. return false;
  238. }
  239. $this->deferred[$item->getKey()] = $item;
  241. return $this->commit();
  242. }
  244. public function saveDeferred(CacheItemInterface $item): bool
  245. {
  246. if (!$item instanceof CacheItem) {
  247. return false;
  248. }
  249. $this->deferred[$item->getKey()] = $item;
  251. return true;
  252. }
  254. /**
  255. * Enables/disables versioning of items.
  256. *
  257. * When versioning is enabled, clearing the cache is atomic and doesn't require listing existing keys to proceed,
  258. * but old keys may need garbage collection and extra round-trips to the back-end are required.
  259. *
  260. * Calling this method also clears the memoized namespace version and thus forces a resynchronization of it.
  261. *
  262. * @return bool the previous state of versioning
  263. */
  264. public function enableVersioning(bool $enable = true): bool
  265. {
  266. $wasEnabled = $this->versioningIsEnabled;
  267. $this->versioningIsEnabled = $enable;
  268. $this->namespaceVersion = '';
  269. $this->ids = [];
  271. return $wasEnabled;
  272. }
  274. public function reset(): void
  275. {
  276. if ($this->deferred) {
  277. $this->commit();
  278. }
  279. $this->namespaceVersion = '';
  280. $this->ids = [];
  281. }
  283. public function __serialize(): array
  284. {
  285. throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  286. }
  288. public function __unserialize(array $data): void
  289. {
  290. throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  291. }
  293. public function __destruct()
  294. {
  295. if ($this->deferred) {
  296. $this->commit();
  297. }
  298. }
  300. private function generateItems(iterable $items, array &$keys): \Generator
  301. {
  302. $f = self::$createCacheItem;
  304. try {
  305. foreach ($items as $id => $value) {
  306. if (!isset($keys[$id])) {
  307. throw new InvalidArgumentException(\sprintf('Could not match value id "%s" to keys "%s".', $id, implode('", "', $keys)));
  308. }
  309. $key = $keys[$id];
  310. unset($keys[$id]);
  311. yield $key => $f($key, $value, true);
  312. }
  313. } catch (\Exception $e) {
  314. CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  315. }
  317. foreach ($keys as $key) {
  318. yield $key => $f($key, null, false);
  319. }
  320. }
  322. /**
  323. * @internal
  324. */
  325. protected function getId(mixed $key): string
  326. {
  327. if ($this->versioningIsEnabled && '' === $this->namespaceVersion) {
  328. $this->ids = [];
  329. $this->namespaceVersion = '1'.static::NS_SEPARATOR;
  330. try {
  331. foreach ($this->doFetch([static::NS_SEPARATOR.$this->namespace]) as $v) {
  332. $this->namespaceVersion = $v;
  333. }
  334. $e = true;
  335. if ('1'.static::NS_SEPARATOR === $this->namespaceVersion) {
  336. $this->namespaceVersion = self::formatNamespaceVersion(time());
  337. $e = $this->doSave([static::NS_SEPARATOR.$this->namespace => $this->namespaceVersion], 0);
  338. }
  339. } catch (\Exception $e) {
  340. }
  341. if (true !== $e && [] !== $e) {
  342. $message = 'Failed to save the new namespace'.($e instanceof \Exception ? ': '.$e->getMessage() : '.');
  343. CacheItem::log($this->logger, $message, ['exception' => $e instanceof \Exception ? $e : null, 'cache-adapter' => get_debug_type($this)]);
  344. }
  345. }
  347. if (\is_string($key) && isset($this->ids[$key])) {
  348. return $this->namespace.$this->namespaceVersion.$this->ids[$key];
  349. }
  350. \assert('' !== CacheItem::validateKey($key));
  351. $this->ids[$key] = $key;
  353. if (\count($this->ids) > 1000) {
  354. $this->ids = \array_slice($this->ids, 500, null, true); // stop memory leak if there are many keys
  355. }
  357. if (null === $this->maxIdLength) {
  358. return $this->namespace.$this->namespaceVersion.$key;
  359. }
  360. if (\strlen($id = $this->namespace.$this->namespaceVersion.$key) > $this->maxIdLength) {
  361. // Use xxh128 to favor speed over security, which is not an issue here
  362. $this->ids[$key] = $id = substr_replace(base64_encode(hash('xxh128', $key, true)), static::NS_SEPARATOR, -(\strlen($this->namespaceVersion) + 2));
  363. $id = $this->namespace.$this->namespaceVersion.$id;
  364. }
  366. return $id;
  367. }
  369. /**
  370. * @internal
  371. */
  372. public static function handleUnserializeCallback(string $class): never
  373. {
  374. throw new \DomainException('Class not found: '.$class);
  375. }
  377. private static function formatNamespaceVersion(int $value): string
  378. {
  379. return strtr(substr_replace(base64_encode(pack('V', $value)), static::NS_SEPARATOR, 5), '/', '_');
  380. }
  381. }