CacheService.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Extbase\Service;
 
use TYPO3\CMS\Backend\Utility\BackendUtility;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
 
class ‪CacheService implements ‪SingletonInterface
{
    protected array ‪$hasPidColumn = [];
    protected array ‪$clearCacheForTables = [];
    protected ‪ConfigurationManagerInterface ‪$configurationManager;
    protected ‪CacheManager ‪$cacheManager;
    protected ‪ConnectionPool ‪$connectionPool;
    protected \SplStack ‪$pageIdStack;
 
    public function ‪__construct(‪ConfigurationManagerInterface ‪$configurationManager, ‪CacheManager ‪$cacheManager)
    {
        $this->configurationManager = ‪$configurationManager;
        $this->cacheManager = ‪$cacheManager;
        $this->pageIdStack = new \SplStack();
        $this->connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
    }
 
    public function ‪getPageIdStack(): \SplStack
    {
        return ‪$this->pageIdStack;
    }
 
    public function ‪clearPageCache($pageIdsToClear = null): void
    {
        if ($pageIdsToClear === null) {
            $this->cacheManager->flushCachesInGroup('pages');
        } else {
            if (!is_array($pageIdsToClear)) {
                $pageIdsToClear = [(int)$pageIdsToClear];
            }
            $tags = array_map(static fn(int $item): string => 'pageId_' . $item, $pageIdsToClear);
            $this->cacheManager->flushCachesInGroupByTags('pages', $tags);
        }
    }
 
    public function ‪clearCachesOfRegisteredPageIds(): void
    {
        $frameworkConfiguration = $this->configurationManager->getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if (!empty($frameworkConfiguration['persistence']['enableAutomaticCacheClearing'] ?? false)) {
            foreach ($this->clearCacheForTables as $table => $ids) {
                foreach ($ids as $id) {
                    $this->‪clearPageCacheForGivenRecord($table, $id);
                }
            }
        }
        if (!$this->pageIdStack->isEmpty()) {
            $pageIds = [];
            while (!$this->pageIdStack->isEmpty()) {
                $pageIds[] = (int)$this->pageIdStack->pop();
            }
            $pageIds = array_values(array_unique($pageIds));
            $this->‪clearPageCache($pageIds);
        }
    }
 
    public function ‪clearCacheForRecord(string $table, int ‪$uid): void
    {
        if (!is_array($this->clearCacheForTables[$table] ?? null)) {
            $this->clearCacheForTables[$table] = [];
        }
        $this->clearCacheForTables[$table][] = ‪$uid;
    }
 
    protected function ‪clearPageCacheForGivenRecord(string $tableName, int ‪$uid): void
    {
        $pageIdsToClear = [];
        $storagePage = null;
 
        // As determining the table columns is a costly operation this is done only once per table during runtime and cached then
        if (!isset($this->hasPidColumn[$tableName])) {
            $columns = $this->connectionPool
                ->getConnectionForTable($tableName)
                ->createSchemaManager()
                ->listTableColumns($tableName);
            $this->hasPidColumn[$tableName] = array_key_exists('pid', $columns);
        }
 
        if ($this->hasPidColumn[$tableName]) {
            $queryBuilder = $this->connectionPool->getQueryBuilderForTable($tableName);
            $queryBuilder->getRestrictions()->removeAll();
            $result = $queryBuilder
                ->select('pid')
                ->from($tableName)
                ->where(
                    $queryBuilder->expr()->eq(
                        'uid',
                        $queryBuilder->createNamedParameter(‪$uid, ‪Connection::PARAM_INT)
                    )
                )
                ->executeQuery();
            if ($row = $result->fetchAssociative()) {
                $storagePage = $row['pid'];
                $pageIdsToClear[] = $storagePage;
            }
        } elseif ($this->‪getTypoScriptFrontendController() !== null) {
            // No PID column - we can do a best-effort to clear the cache of the current page if in FE
            $storagePage = $this->‪getTypoScriptFrontendController()->id;
            $pageIdsToClear[] = $storagePage;
        }
        if ($storagePage === null) {
            return;
        }
 
        $pageTS = BackendUtility::getPagesTSconfig($storagePage);
        if (isset($pageTS['TCEMAIN.']['clearCacheCmd'])) {
            $clearCacheCommands = GeneralUtility::trimExplode(',', strtolower((string)$pageTS['TCEMAIN.']['clearCacheCmd']), true);
            $clearCacheCommands = array_unique($clearCacheCommands);
            foreach ($clearCacheCommands as $clearCacheCommand) {
                if (‪MathUtility::canBeInterpretedAsInteger($clearCacheCommand)) {
                    $pageIdsToClear[] = $clearCacheCommand;
                }
            }
        }
 
        foreach ($pageIdsToClear as $pageIdToClear) {
            $this->‪getPageIdStack()->push($pageIdToClear);
        }
    }
 
    protected function ‪getTypoScriptFrontendController(): ?‪TypoScriptFrontendController
    {
        return ‪$GLOBALS['TSFE'] ?? null;
    }
}