SiteConfiguration::getCache() - Code Metrics - Inspection of "[TASK] Inject cache into SiteConfiguration" - TYPO3/TYPO3.CMS - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e833d0...081de4 )

unknown

created 2021-02-11 21:24 UTC

SiteConfiguration::getCache() A

↳ Parent: SiteConfiguration

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?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\Core\Configuration;

use Symfony\Component\Finder\Finder;
use Symfony\Component\Yaml\Yaml;
use TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;
use TYPO3\CMS\Core\Configuration\Loader\YamlFileLoader;
use TYPO3\CMS\Core\Exception\SiteNotFoundException;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Core\Site\Entity\Site;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * Responsibility: Handles the format of the configuration (currently yaml), and the location of the file system folder
 *
 * Reads all available site configuration options, and puts them into Site objects.
 *
 * @internal
 */
class SiteConfiguration implements SingletonInterface
{
    protected PhpFrontend $cache;

    /**
     * @var string
     */
    protected $configPath;

    /**
     * Config yaml file name.
     *
     * @internal
     * @var string
     */
    protected $configFileName = 'config.yaml';

    /**
     * Identifier to store all configuration data in cache_core cache.
     *
     * @internal
     * @var string
     */
    protected $cacheIdentifier = 'sites-configuration';

    /**
     * Cache stores all configuration as Site objects, as long as they haven't been changed.
     * This drastically improves performance as SiteFinder utilizes SiteConfiguration heavily
     *
     * @var array|null
     */
    protected $firstLevelCache;

    /**
     * @param string $configPath
     * @param PhpFrontend $coreCache
     */
    public function __construct(string $configPath, PhpFrontend $coreCache = null)
    {
        $this->configPath = $configPath;
        // The following fallback to GeneralUtility;:getContainer() is only used in acceptance tests
        // @todo: Fix testing-framework/typo3/sysext/core/Classes/Configuration/SiteConfiguration.php
        // to inject the cache instance
        $this->cache = $coreCache ?? GeneralUtility::getContainer()->get('cache.core');
    }

    /**
     * Return all site objects which have been found in the filesystem.
     *
     * @param bool $useCache
     * @return Site[]
     */
    public function getAllExistingSites(bool $useCache = true): array
    {
        if ($useCache && $this->firstLevelCache !== null) {
            return $this->firstLevelCache;
        }
        return $this->resolveAllExistingSites($useCache);
    }

    /**
     * Creates a site configuration with one language "English" which is the de-facto default language for TYPO3 in general.
     *
     * @param string $identifier
     * @param int $rootPageId
     * @param string $base
     */
    public function createNewBasicSite(string $identifier, int $rootPageId, string $base): void
    {
        // Create a default site configuration called "main" as best practice
        $this->write($identifier, [
            'rootPageId' => $rootPageId,
            'base' => $base,
            'languages' => [
                0 => [
                    'title' => 'English',
                    'enabled' => true,
                    'languageId' => 0,
                    'base' => '/',
                    'typo3Language' => 'default',
                    'locale' => 'en_US.UTF-8',
                    'iso-639-1' => 'en',
                    'navigationTitle' => 'English',
                    'hreflang' => 'en-us',
                    'direction' => 'ltr',
                    'flag' => 'us',
                ],
            ],
            'errorHandling' => [],
            'routes' => [],
        ]);
    }

    /**
     * Resolve all site objects which have been found in the filesystem.
     *
     * @param bool $useCache
     * @return Site[]
     */
    public function resolveAllExistingSites(bool $useCache = true): array
    {
        $sites = [];
        $siteConfiguration = $this->getAllSiteConfigurationFromFiles($useCache);
        foreach ($siteConfiguration as $identifier => $configuration) {
            $rootPageId = (int)($configuration['rootPageId'] ?? 0);
            if ($rootPageId > 0) {
                $sites[$identifier] = GeneralUtility::makeInstance(Site::class, $identifier, $rootPageId, $configuration);
            }
        }
        $this->firstLevelCache = $sites;
        return $sites;
    }

    /**
     * Read the site configuration from config files.
     *
     * @param bool $useCache
     * @return array
     * @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
     */
    protected function getAllSiteConfigurationFromFiles(bool $useCache = true): array
    {
        // Check if the data is already cached
        $siteConfiguration = $useCache ? $this->cache->require($this->cacheIdentifier) : false;
        if ($siteConfiguration !== false) {
            return $siteConfiguration;
        }
        $finder = new Finder();
        try {
            $finder->files()->depth(0)->name($this->configFileName)->in($this->configPath . '/*');
        } catch (\InvalidArgumentException $e) {
            // Directory $this->configPath does not exist yet
            $finder = [];
        }
        $loader = GeneralUtility::makeInstance(YamlFileLoader::class);
        $siteConfiguration = [];
        foreach ($finder as $fileInfo) {
            $configuration = $loader->load(GeneralUtility::fixWindowsFilePath((string)$fileInfo));
            $identifier = basename($fileInfo->getPath());
            $siteConfiguration[$identifier] = $configuration;
        }
        $this->cache->set($this->cacheIdentifier, 'return ' . var_export($siteConfiguration, true) . ';');

        return $siteConfiguration;
    }

    /**
     * Load plain configuration
     * This method should only be used in case the original configuration as it exists in the file should be loaded,
     * for example for writing / editing configuration.
     *
     * All read related actions should be performed on the site entity.
     *
     * @param string $siteIdentifier
     * @return array
     */
    public function load(string $siteIdentifier): array
    {
        $fileName = $this->configPath . '/' . $siteIdentifier . '/' . $this->configFileName;
        $loader = GeneralUtility::makeInstance(YamlFileLoader::class);
        return $loader->load(GeneralUtility::fixWindowsFilePath($fileName), YamlFileLoader::PROCESS_IMPORTS);
    }

    /**
     * Add or update a site configuration
     *
     * @param string $siteIdentifier
     * @param array $configuration
     * @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
     */
    public function write(string $siteIdentifier, array $configuration): void
    {
        $folder = $this->configPath . '/' . $siteIdentifier;
        $fileName = $folder . '/' . $this->configFileName;
        $newConfiguration = $configuration;
        if (!file_exists($folder)) {
            GeneralUtility::mkdir_deep($folder);
        } elseif (file_exists($fileName)) {
            $loader = GeneralUtility::makeInstance(YamlFileLoader::class);
            // load without any processing to have the unprocessed base to modify
            $newConfiguration = $loader->load(GeneralUtility::fixWindowsFilePath($fileName), 0);
            // load the processed configuration to diff changed values
            $processed = $loader->load(GeneralUtility::fixWindowsFilePath($fileName));
            // find properties that were modified via GUI
            $newModified = array_replace_recursive(
                self::findRemoved($processed, $configuration),
                self::findModified($processed, $configuration)
            );
            // change _only_ the modified keys, leave the original non-changed areas alone
            ArrayUtility::mergeRecursiveWithOverrule($newConfiguration, $newModified);
        }
        $newConfiguration = $this->sortConfiguration($newConfiguration);
        $yamlFileContents = Yaml::dump($newConfiguration, 99, 2);
        GeneralUtility::writeFile($fileName, $yamlFileContents);
        $this->firstLevelCache = null;
        $this->cache->remove($this->cacheIdentifier);
    }

    /**
     * Renames a site identifier (and moves the folder)
     *
     * @param string $currentIdentifier
     * @param string $newIdentifier
     * @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
     */
    public function rename(string $currentIdentifier, string $newIdentifier): void
    {
        $result = rename($this->configPath . '/' . $currentIdentifier, $this->configPath . '/' . $newIdentifier);
        if (!$result) {
            throw new \RuntimeException('Unable to rename folder sites/' . $currentIdentifier, 1522491300);
        }
        $this->cache->remove($this->cacheIdentifier);
        $this->firstLevelCache = null;
    }

    /**
     * Removes the config.yaml file of a site configuration.
     * Also clears the cache.
     *
     * @param string $siteIdentifier
     * @throws SiteNotFoundException
     */
    public function delete(string $siteIdentifier): void
    {
        $sites = $this->getAllExistingSites();
        if (!isset($sites[$siteIdentifier])) {
            throw new SiteNotFoundException('Site configuration named ' . $siteIdentifier . ' not found.', 1522866183);
        }
        $fileName = $this->configPath . '/' . $siteIdentifier . '/' . $this->configFileName;
        if (!file_exists($fileName)) {
            throw new SiteNotFoundException('Site configuration file ' . $this->configFileName . ' within the site ' . $siteIdentifier . ' not found.', 1522866184);
        }
        @unlink($fileName);
        $this->cache->remove($this->cacheIdentifier);
        $this->firstLevelCache = null;
    }

    /**
     * @param array $newConfiguration
     * @return array
     */
    protected function sortConfiguration(array $newConfiguration): array
    {
        ksort($newConfiguration);
        if (isset($newConfiguration['imports'])) {
            $imports = $newConfiguration['imports'];
            unset($newConfiguration['imports']);
            $newConfiguration['imports'] = $imports;
        }
        return $newConfiguration;
    }

    protected static function findModified(array $currentConfiguration, array $newConfiguration): array
    {
        $differences = [];
        foreach ($newConfiguration as $key => $value) {
            if (!isset($currentConfiguration[$key]) || $currentConfiguration[$key] !== $newConfiguration[$key]) {
                if (!isset($newConfiguration[$key]) && isset($currentConfiguration[$key])) {
                    $differences[$key] = '__UNSET';
                } elseif (isset($currentConfiguration[$key])
                    && is_array($newConfiguration[$key])
                    && is_array($currentConfiguration[$key])
                ) {
                    $differences[$key] = self::findModified($currentConfiguration[$key], $newConfiguration[$key]);
                } else {
                    $differences[$key] = $value;
                }
            }
        }
        return $differences;
    }

    protected static function findRemoved(array $currentConfiguration, array $newConfiguration): array
    {
        $removed = [];
        foreach ($currentConfiguration as $key => $value) {
            if (!isset($newConfiguration[$key])) {
                $removed[$key] = '__UNSET';
            } elseif (isset($currentConfiguration[$key]) && is_array($currentConfiguration[$key]) && is_array($newConfiguration[$key])) {
                $removedInRecursion = self::findRemoved($currentConfiguration[$key], $newConfiguration[$key]);
                if (!empty($removedInRecursion)) {
                    $removed[$key] = $removedInRecursion;
                }
            }
        }

        return $removed;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the TYPO3 CMS project.
7			*
8			* It is free software; you can redistribute it and/or modify it under
9			* the terms of the GNU General Public License, either version 2
10			* of the License, or any later version.
11			*
12			* For the full copyright and license information, please read the
13			* LICENSE.txt file that was distributed with this source code.
14			*
15			* The TYPO3 project - inspiring people to share!
16			*/
17
18			namespace TYPO3\CMS\Core\Configuration;
19
20			use Symfony\Component\Finder\Finder;
21			use Symfony\Component\Yaml\Yaml;
22			use TYPO3\CMS\Core\Cache\Frontend\PhpFrontend;
23			use TYPO3\CMS\Core\Configuration\Loader\YamlFileLoader;
24			use TYPO3\CMS\Core\Exception\SiteNotFoundException;
25			use TYPO3\CMS\Core\SingletonInterface;
26			use TYPO3\CMS\Core\Site\Entity\Site;
27			use TYPO3\CMS\Core\Utility\ArrayUtility;
28			use TYPO3\CMS\Core\Utility\GeneralUtility;
29
30			/**
31			* Responsibility: Handles the format of the configuration (currently yaml), and the location of the file system folder
32			*
33			* Reads all available site configuration options, and puts them into Site objects.
34			*
35			* @internal
36			*/
37			class SiteConfiguration implements SingletonInterface
38			{
39			protected PhpFrontend $cache;
40
41			/**
42			* @var string
43			*/
44			protected $configPath;
45
46			/**
47			* Config yaml file name.
48			*
49			* @internal
50			* @var string
51			*/
52			protected $configFileName = 'config.yaml';
53
54			/**
55			* Identifier to store all configuration data in cache_core cache.
56			*
57			* @internal
58			* @var string
59			*/
60			protected $cacheIdentifier = 'sites-configuration';
61
62			/**
63			* Cache stores all configuration as Site objects, as long as they haven't been changed.
64			* This drastically improves performance as SiteFinder utilizes SiteConfiguration heavily
65			*
66			* @var array\|null
67			*/
68			protected $firstLevelCache;
69
70			/**
71			* @param string $configPath
72			* @param PhpFrontend $coreCache
73			*/
74			public function __construct(string $configPath, PhpFrontend $coreCache = null)
75			{
76			$this->configPath = $configPath;
77			// The following fallback to GeneralUtility;:getContainer() is only used in acceptance tests
78			// @todo: Fix testing-framework/typo3/sysext/core/Classes/Configuration/SiteConfiguration.php
79			// to inject the cache instance
80			$this->cache = $coreCache ?? GeneralUtility::getContainer()->get('cache.core');
81			}
82
83			/**
84			* Return all site objects which have been found in the filesystem.
85			*
86			* @param bool $useCache
87			* @return Site[]
88			*/
89			public function getAllExistingSites(bool $useCache = true): array
90			{
91			if ($useCache && $this->firstLevelCache !== null) {
92			return $this->firstLevelCache;
93			}
94			return $this->resolveAllExistingSites($useCache);
95			}
96
97			/**
98			* Creates a site configuration with one language "English" which is the de-facto default language for TYPO3 in general.
99			*
100			* @param string $identifier
101			* @param int $rootPageId
102			* @param string $base
103			*/
104			public function createNewBasicSite(string $identifier, int $rootPageId, string $base): void
105			{
106			// Create a default site configuration called "main" as best practice
107			$this->write($identifier, [
108			'rootPageId' => $rootPageId,
109			'base' => $base,
110			'languages' => [
111			0 => [
112			'title' => 'English',
113			'enabled' => true,
114			'languageId' => 0,
115			'base' => '/',
116			'typo3Language' => 'default',
117			'locale' => 'en_US.UTF-8',
118			'iso-639-1' => 'en',
119			'navigationTitle' => 'English',
120			'hreflang' => 'en-us',
121			'direction' => 'ltr',
122			'flag' => 'us',
123			],
124			],
125			'errorHandling' => [],
126			'routes' => [],
127			]);
128			}
129
130			/**
131			* Resolve all site objects which have been found in the filesystem.
132			*
133			* @param bool $useCache
134			* @return Site[]
135			*/
136			public function resolveAllExistingSites(bool $useCache = true): array
137			{
138			$sites = [];
139			$siteConfiguration = $this->getAllSiteConfigurationFromFiles($useCache);
140			foreach ($siteConfiguration as $identifier => $configuration) {
141			$rootPageId = (int)($configuration['rootPageId'] ?? 0);
142			if ($rootPageId > 0) {
143			$sites[$identifier] = GeneralUtility::makeInstance(Site::class, $identifier, $rootPageId, $configuration);
144			}
145			}
146			$this->firstLevelCache = $sites;
147			return $sites;
148			}
149
150			/**
151			* Read the site configuration from config files.
152			*
153			* @param bool $useCache
154			* @return array
155			* @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
156			*/
157			protected function getAllSiteConfigurationFromFiles(bool $useCache = true): array
158			{
159			// Check if the data is already cached
160			$siteConfiguration = $useCache ? $this->cache->require($this->cacheIdentifier) : false;
161			if ($siteConfiguration !== false) {
162			return $siteConfiguration;
163			}
164			$finder = new Finder();
165			try {
166			$finder->files()->depth(0)->name($this->configFileName)->in($this->configPath . '/*');
167			} catch (\InvalidArgumentException $e) {
168			// Directory $this->configPath does not exist yet
169			$finder = [];
170			}
171			$loader = GeneralUtility::makeInstance(YamlFileLoader::class);
172			$siteConfiguration = [];
173			foreach ($finder as $fileInfo) {
174			$configuration = $loader->load(GeneralUtility::fixWindowsFilePath((string)$fileInfo));
175			$identifier = basename($fileInfo->getPath());
176			$siteConfiguration[$identifier] = $configuration;
177			}
178			$this->cache->set($this->cacheIdentifier, 'return ' . var_export($siteConfiguration, true) . ';');
179
180			return $siteConfiguration;
181			}
182
183			/**
184			* Load plain configuration
185			* This method should only be used in case the original configuration as it exists in the file should be loaded,
186			* for example for writing / editing configuration.
187			*
188			* All read related actions should be performed on the site entity.
189			*
190			* @param string $siteIdentifier
191			* @return array
192			*/
193			public function load(string $siteIdentifier): array
194			{
195			$fileName = $this->configPath . '/' . $siteIdentifier . '/' . $this->configFileName;
196			$loader = GeneralUtility::makeInstance(YamlFileLoader::class);
197			return $loader->load(GeneralUtility::fixWindowsFilePath($fileName), YamlFileLoader::PROCESS_IMPORTS);
198			}
199
200			/**
201			* Add or update a site configuration
202			*
203			* @param string $siteIdentifier
204			* @param array $configuration
205			* @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
206			*/
207			public function write(string $siteIdentifier, array $configuration): void
208			{
209			$folder = $this->configPath . '/' . $siteIdentifier;
210			$fileName = $folder . '/' . $this->configFileName;
211			$newConfiguration = $configuration;
212			if (!file_exists($folder)) {
213			GeneralUtility::mkdir_deep($folder);
214			} elseif (file_exists($fileName)) {
215			$loader = GeneralUtility::makeInstance(YamlFileLoader::class);
216			// load without any processing to have the unprocessed base to modify
217			$newConfiguration = $loader->load(GeneralUtility::fixWindowsFilePath($fileName), 0);
218			// load the processed configuration to diff changed values
219			$processed = $loader->load(GeneralUtility::fixWindowsFilePath($fileName));
220			// find properties that were modified via GUI
221			$newModified = array_replace_recursive(
222			self::findRemoved($processed, $configuration),
223			self::findModified($processed, $configuration)
224			);
225			// change _only_ the modified keys, leave the original non-changed areas alone
226			ArrayUtility::mergeRecursiveWithOverrule($newConfiguration, $newModified);
227			}
228			$newConfiguration = $this->sortConfiguration($newConfiguration);
229			$yamlFileContents = Yaml::dump($newConfiguration, 99, 2);
230			GeneralUtility::writeFile($fileName, $yamlFileContents);
231			$this->firstLevelCache = null;
232			$this->cache->remove($this->cacheIdentifier);
233			}
234
235			/**
236			* Renames a site identifier (and moves the folder)
237			*
238			* @param string $currentIdentifier
239			* @param string $newIdentifier
240			* @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
241			*/
242			public function rename(string $currentIdentifier, string $newIdentifier): void
243			{
244			$result = rename($this->configPath . '/' . $currentIdentifier, $this->configPath . '/' . $newIdentifier);
245			if (!$result) {
246			throw new \RuntimeException('Unable to rename folder sites/' . $currentIdentifier, 1522491300);
247			}
248			$this->cache->remove($this->cacheIdentifier);
249			$this->firstLevelCache = null;
250			}
251
252			/**
253			* Removes the config.yaml file of a site configuration.
254			* Also clears the cache.
255			*
256			* @param string $siteIdentifier
257			* @throws SiteNotFoundException
258			*/
259			public function delete(string $siteIdentifier): void
260			{
261			$sites = $this->getAllExistingSites();
262			if (!isset($sites[$siteIdentifier])) {
263			throw new SiteNotFoundException('Site configuration named ' . $siteIdentifier . ' not found.', 1522866183);
264			}
265			$fileName = $this->configPath . '/' . $siteIdentifier . '/' . $this->configFileName;
266			if (!file_exists($fileName)) {
267			throw new SiteNotFoundException('Site configuration file ' . $this->configFileName . ' within the site ' . $siteIdentifier . ' not found.', 1522866184);
268			}
269			@unlink($fileName);
270			$this->cache->remove($this->cacheIdentifier);
271			$this->firstLevelCache = null;
272			}
273
274			/**
275			* @param array $newConfiguration
276			* @return array
277			*/
278			protected function sortConfiguration(array $newConfiguration): array
279			{
280			ksort($newConfiguration);
281			if (isset($newConfiguration['imports'])) {
282			$imports = $newConfiguration['imports'];
283			unset($newConfiguration['imports']);
284			$newConfiguration['imports'] = $imports;
285			}
286			return $newConfiguration;
287			}
288
289			protected static function findModified(array $currentConfiguration, array $newConfiguration): array
290			{
291			$differences = [];
292			foreach ($newConfiguration as $key => $value) {
293			if (!isset($currentConfiguration[$key]) \|\| $currentConfiguration[$key] !== $newConfiguration[$key]) {
294			if (!isset($newConfiguration[$key]) && isset($currentConfiguration[$key])) {
295			$differences[$key] = '__UNSET';
296			} elseif (isset($currentConfiguration[$key])
297			&& is_array($newConfiguration[$key])
298			&& is_array($currentConfiguration[$key])
299			) {
300			$differences[$key] = self::findModified($currentConfiguration[$key], $newConfiguration[$key]);
301			} else {
302			$differences[$key] = $value;
303			}
304			}
305			}
306			return $differences;
307			}
308
309			protected static function findRemoved(array $currentConfiguration, array $newConfiguration): array
310			{
311			$removed = [];
312			foreach ($currentConfiguration as $key => $value) {
313			if (!isset($newConfiguration[$key])) {
314			$removed[$key] = '__UNSET';
315			} elseif (isset($currentConfiguration[$key]) && is_array($currentConfiguration[$key]) && is_array($newConfiguration[$key])) {
316			$removedInRecursion = self::findRemoved($currentConfiguration[$key], $newConfiguration[$key]);
317			if (!empty($removedInRecursion)) {
318			$removed[$key] = $removedInRecursion;
319			}
320			}
321			}
322
323			return $removed;
324			}
325			}
326

TYPO3 / TYPO3.CMS

Push — master ( e833d0...081de4 )

SiteConfiguration::getCache() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like