ConfigurationManager.php

Go to the documentation of this file.

<?php
 
/*
 * 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 ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Crypto\Random;
use ‪TYPO3\CMS\Core\Service\OpcodeCacheService;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ConfigurationManager
{
    protected $defaultConfigurationFile = 'core/Configuration/DefaultConfiguration.php';
 
    protected $defaultConfigurationDescriptionFile = 'core/Configuration/DefaultConfigurationDescription.yaml';
 
    protected $localConfigurationFile = 'LocalConfiguration.php';
 
    protected $additionalConfigurationFile = 'AdditionalConfiguration.php';
 
    protected $factoryConfigurationFile = 'core/Configuration/FactoryConfiguration.php';
 
    protected $additionalFactoryConfigurationFile = 'AdditionalFactoryConfiguration.php';
 
    protected $whiteListedLocalConfigurationPaths = [
        'EXTCONF',
        'DB',
        'SYS/caching/cacheConfigurations',
        'SYS/session',
        'EXTENSIONS',
    ];
 
    public function getDefaultConfiguration()
    {
        return require $this->getDefaultConfigurationFileLocation();
    }
 
    public function getDefaultConfigurationFileLocation()
    {
        return ‪Environment::getFrameworkBasePath() . '/' . $this->defaultConfigurationFile;
    }
 
    public function getDefaultConfigurationDescriptionFileLocation()
    {
        return ‪Environment::getFrameworkBasePath() . '/' . $this->defaultConfigurationDescriptionFile;
    }
 
    public function getLocalConfiguration()
    {
        return require $this->getLocalConfigurationFileLocation();
    }
 
    public function getLocalConfigurationFileLocation()
    {
        return ‪Environment::getLegacyConfigPath() . '/' . $this->localConfigurationFile;
    }
 
    public function getMergedLocalConfiguration(): array
    {
        $localConfiguration = $this->getDefaultConfiguration();
        ‪ArrayUtility::mergeRecursiveWithOverrule($localConfiguration, $this->getLocalConfiguration());
        return $localConfiguration;
    }
 
    public function getAdditionalConfigurationFileLocation()
    {
        return ‪Environment::getLegacyConfigPath() . '/' . $this->additionalConfigurationFile;
    }
 
    protected function getFactoryConfigurationFileLocation()
    {
        return ‪Environment::getFrameworkBasePath() . '/' . $this->factoryConfigurationFile;
    }
 
    protected function getAdditionalFactoryConfigurationFileLocation()
    {
        return ‪Environment::getLegacyConfigPath() . '/' . $this->additionalFactoryConfigurationFile;
    }
 
    public function updateLocalConfiguration(array $configurationToMerge)
    {
        $newLocalConfiguration = $this->getLocalConfiguration();
        ‪ArrayUtility::mergeRecursiveWithOverrule($newLocalConfiguration, $configurationToMerge);
        $this->writeLocalConfiguration($newLocalConfiguration);
    }
 
    public function getDefaultConfigurationValueByPath($path)
    {
        return ‪ArrayUtility::getValueByPath($this->getDefaultConfiguration(), $path);
    }
 
    public function getLocalConfigurationValueByPath($path)
    {
        return ‪ArrayUtility::getValueByPath($this->getLocalConfiguration(), $path);
    }
 
    public function getConfigurationValueByPath($path)
    {
        $defaultConfiguration = $this->getDefaultConfiguration();
        ‪ArrayUtility::mergeRecursiveWithOverrule($defaultConfiguration, $this->getLocalConfiguration());
        return ‪ArrayUtility::getValueByPath($defaultConfiguration, $path);
    }
 
    public function setLocalConfigurationValueByPath($path, $value)
    {
        $result = false;
        if ($this->isValidLocalConfigurationPath($path)) {
            $localConfiguration = $this->getLocalConfiguration();
            $localConfiguration = ‪ArrayUtility::setValueByPath($localConfiguration, $path, $value);
            $result = $this->writeLocalConfiguration($localConfiguration);
        }
        return $result;
    }
 
    public function setLocalConfigurationValuesByPathValuePairs(array $pairs)
    {
        $localConfiguration = $this->getLocalConfiguration();
        foreach ($pairs as $path => $value) {
            if ($this->isValidLocalConfigurationPath($path)) {
                $localConfiguration = ‪ArrayUtility::setValueByPath($localConfiguration, $path, $value);
            }
        }
        return $this->writeLocalConfiguration($localConfiguration);
    }
 
    public function removeLocalConfigurationKeysByPath(array $keys)
    {
        $result = false;
        $localConfiguration = $this->getLocalConfiguration();
        foreach ($keys as $path) {
            // Remove key if path is within LocalConfiguration
            if (‪ArrayUtility::isValidPath($localConfiguration, $path)) {
                $result = true;
                $localConfiguration = ‪ArrayUtility::removeByPath($localConfiguration, $path);
            }
        }
        if ($result) {
            $this->writeLocalConfiguration($localConfiguration);
        }
        return $result;
    }
 
    public function enableFeature(string $featureName): bool
    {
        return $this->setLocalConfigurationValueByPath('SYS/features/' . $featureName, true);
    }
 
    public function disableFeature(string $featureName): bool
    {
        return $this->setLocalConfigurationValueByPath('SYS/features/' . $featureName, false);
    }
 
    public function canWriteConfiguration()
    {
        $fileLocation = $this->getLocalConfigurationFileLocation();
        return @is_writable(file_exists($fileLocation) ? $fileLocation : ‪Environment::getLegacyConfigPath() . '/');
    }
 
    public function exportConfiguration()
    {
        if (@is_file($this->getLocalConfigurationFileLocation())) {
            $localConfiguration = $this->getLocalConfiguration();
            if (is_array($localConfiguration)) {
                $defaultConfiguration = $this->getDefaultConfiguration();
                ‪ArrayUtility::mergeRecursiveWithOverrule($defaultConfiguration, $localConfiguration);
                ‪$GLOBALS['TYPO3_CONF_VARS'] = $defaultConfiguration;
            } else {
                throw new \UnexpectedValueException('LocalConfiguration invalid.', 1349272276);
            }
        } else {
            // No LocalConfiguration (yet), load DefaultConfiguration
            ‪$GLOBALS['TYPO3_CONF_VARS'] = $this->getDefaultConfiguration();
        }
 
        // Load AdditionalConfiguration
        if (@is_file($this->getAdditionalConfigurationFileLocation())) {
            require $this->getAdditionalConfigurationFileLocation();
        }
    }
 
    public function writeLocalConfiguration(array $configuration)
    {
        $localConfigurationFile = $this->getLocalConfigurationFileLocation();
        if (!$this->canWriteConfiguration()) {
            throw new \RuntimeException(
                $localConfigurationFile . ' is not writable.',
                1346323822
            );
        }
        $configuration = ‪ArrayUtility::sortByKeyRecursive($configuration);
        $result = ‪GeneralUtility::writeFile(
            $localConfigurationFile,
            "<?php\n" .
                'return ' .
                    ‪ArrayUtility::arrayExport($configuration) .
                ";\n",
            true
        );
 
        GeneralUtility::makeInstance(OpcodeCacheService::class)->clearAllActive($localConfigurationFile);
 
        return $result;
    }
 
    public function writeAdditionalConfiguration(array $additionalConfigurationLines)
    {
        return ‪GeneralUtility::writeFile(
            $this->getAdditionalConfigurationFileLocation(),
            "<?php\n" . implode("\n", $additionalConfigurationLines) . "\n"
        );
    }
 
    public function createLocalConfigurationFromFactoryConfiguration()
    {
        if (file_exists($this->getLocalConfigurationFileLocation())) {
            throw new \RuntimeException(
                'LocalConfiguration.php exists already',
                1364836026
            );
        }
        $localConfigurationArray = require $this->getFactoryConfigurationFileLocation();
        $additionalFactoryConfigurationFileLocation = $this->getAdditionalFactoryConfigurationFileLocation();
        if (file_exists($additionalFactoryConfigurationFileLocation)) {
            $additionalFactoryConfigurationArray = require $additionalFactoryConfigurationFileLocation;
            ‪ArrayUtility::mergeRecursiveWithOverrule(
                $localConfigurationArray,
                $additionalFactoryConfigurationArray
            );
        }
        $randomKey = GeneralUtility::makeInstance(Random::class)->generateRandomHexString(96);
        $localConfigurationArray['SYS']['encryptionKey'] = $randomKey;
 
        $this->writeLocalConfiguration($localConfigurationArray);
    }
 
    protected function isValidLocalConfigurationPath($path)
    {
        // Early return for white listed paths
        foreach ($this->whiteListedLocalConfigurationPaths as $whiteListedPath) {
            if (GeneralUtility::isFirstPartOfStr($path, $whiteListedPath)) {
                return true;
            }
        }
        return ‪ArrayUtility::isValidPath($this->getDefaultConfiguration(), $path);
    }
}