ConfigurationManager.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Configuration;

use TYPO3\CMS\Core\Utility;

class ConfigurationManager {

    protected $defaultConfigurationFile = 'typo3/sysext/core/Configuration/DefaultConfiguration.php';

    protected $localConfigurationFile = 'typo3conf/LocalConfiguration.php';

    protected $additionalConfigurationFile = 'typo3conf/AdditionalConfiguration.php';

    protected $factoryConfigurationFile = 'typo3/sysext/core/Configuration/FactoryConfiguration.php';

    protected $additionalFactoryConfigurationFile = 'typo3conf/AdditionalFactoryConfiguration.php';

    protected $pathTypo3Conf = PATH_typo3conf;

    protected $whiteListedLocalConfigurationPaths = array(
        'EXT/extConf',
        'EXTCONF',
        'INSTALL/wizardDone',
        'DB',
        'SYS/caching/cacheConfigurations',
    );

    public function getDefaultConfiguration() {
        return require $this->getDefaultConfigurationFileLocation();
    }

    public function getDefaultConfigurationFileLocation() {
        return PATH_site . $this->defaultConfigurationFile;
    }

    public function getLocalConfiguration() {
        return require $this->getLocalConfigurationFileLocation();
    }

    public function getLocalConfigurationFileLocation() {
        return PATH_site . $this->localConfigurationFile;
    }

    public function getAdditionalConfigurationFileLocation() {
        return PATH_site . $this->additionalConfigurationFile;
    }

    protected function getFactoryConfigurationFileLocation() {
        return PATH_site . $this->factoryConfigurationFile;
    }

    protected function getAdditionalFactoryConfigurationFileLocation() {
        return PATH_site . $this->additionalFactoryConfigurationFile;
    }

    public function updateLocalConfiguration(array $configurationToMerge) {
        $newLocalConfiguration = $this->getLocalConfiguration();
        Utility\ArrayUtility::mergeRecursiveWithOverrule($newLocalConfiguration, $configurationToMerge);
        $this->writeLocalConfiguration($newLocalConfiguration);
    }

    public function getDefaultConfigurationValueByPath($path) {
        return Utility\ArrayUtility::getValueByPath($this->getDefaultConfiguration(), $path);
    }

    public function getLocalConfigurationValueByPath($path) {
        return Utility\ArrayUtility::getValueByPath($this->getLocalConfiguration(), $path);
    }

    public function getConfigurationValueByPath($path) {
        $defaultConfiguration = $this->getDefaultConfiguration();
        Utility\ArrayUtility::mergeRecursiveWithOverrule($defaultConfiguration, $this->getLocalConfiguration());
        return Utility\ArrayUtility::getValueByPath($defaultConfiguration, $path);
    }

    public function setLocalConfigurationValueByPath($path, $value) {
        $result = FALSE;
        if ($this->isValidLocalConfigurationPath($path)) {
            $localConfiguration = $this->getLocalConfiguration();
            $localConfiguration = Utility\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 = Utility\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 (Utility\ArrayUtility::isValidPath($localConfiguration, $path)) {
                $result = TRUE;
                $localConfiguration = Utility\ArrayUtility::removeByPath($localConfiguration, $path);
            }
        }
        if ($result) {
            $this->writeLocalConfiguration($localConfiguration);
        }
        return $result;
    }

    public function canWriteConfiguration() {
        $fileLocation = $this->getLocalConfigurationFileLocation();
        return @is_writable($this->pathTypo3Conf) && (!file_exists($fileLocation) || @is_writable($fileLocation));
    }

    public function exportConfiguration() {
        if (@is_file($this->getLocalConfigurationFileLocation())) {
            $localConfiguration = $this->getLocalConfiguration();
            if (is_array($localConfiguration)) {
                $defaultConfiguration = $this->getDefaultConfiguration();
                Utility\ArrayUtility::mergeRecursiveWithOverrule($defaultConfiguration, $localConfiguration);
                $GLOBALS['TYPO3_CONF_VARS'] = $defaultConfiguration;
            } else {
                throw new \UnexpectedValueException('LocalConfiguration invalid.', 1349272276);
            }
            if (@is_file($this->getAdditionalConfigurationFileLocation())) {
                require $this->getAdditionalConfigurationFileLocation();
            }
        } else {
            // No LocalConfiguration (yet), load DefaultConfiguration only
            $GLOBALS['TYPO3_CONF_VARS'] = $this->getDefaultConfiguration();
        }
    }

    public function writeLocalConfiguration(array $configuration) {
        $localConfigurationFile = $this->getLocalConfigurationFileLocation();
        if (!$this->canWriteConfiguration()) {
            throw new \RuntimeException(
                $localConfigurationFile . ' is not writable.', 1346323822
            );
        }
        $configuration = Utility\ArrayUtility::sortByKeyRecursive($configuration);
        $result = Utility\GeneralUtility::writeFile(
            $localConfigurationFile,
            '<?php' . LF .
                'return ' .
                    Utility\ArrayUtility::arrayExport(
                        Utility\ArrayUtility::renumberKeysToAvoidLeapsIfKeysAreAllNumeric($configuration)
                    ) .
                ';' . LF .
            '?>',
            TRUE
        );

        Utility\OpcodeCacheUtility::clearAllActive($localConfigurationFile);

        return $result;
    }

    public function writeAdditionalConfiguration(array $additionalConfigurationLines) {
        return Utility\GeneralUtility::writeFile(
            PATH_site . $this->additionalConfigurationFile,
            '<?php' . LF .
                implode(LF, $additionalConfigurationLines) . LF .
            '?>'
        );
    }

    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;
            Utility\ArrayUtility::mergeRecursiveWithOverrule(
                $localConfigurationArray,
                $additionalFactoryConfigurationArray
            );
        }
        $this->writeLocalConfiguration($localConfigurationArray);
    }

    protected function isValidLocalConfigurationPath($path) {
        // Early return for white listed paths
        foreach ($this->whiteListedLocalConfigurationPaths as $whiteListedPath) {
            if (Utility\GeneralUtility::isFirstPartOfStr($path, $whiteListedPath)) {
                return TRUE;
            }
        }
        return Utility\ArrayUtility::isValidPath($this->getDefaultConfiguration(), $path);
    }

}