StepController.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Install\Controller;

/*
 * 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!
 */

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Install\Service\SilentConfigurationUpgradeService;

class StepController extends AbstractController
{
    protected $authenticationActions = [
        'environmentAndFolders',
        'databaseConnect',
        'databaseSelect',
        'databaseData',
        'defaultConfiguration',
    ];

    public function execute()
    {
        $this->loadBaseExtensions();
        $this->outputInstallToolNotEnabledMessageIfNeeded();
        $this->outputInstallToolPasswordNotSetMessageIfNeeded();
        $this->recreatePackageStatesFileIfNotExisting();
        $this->executeOrOutputFirstInstallStepIfNeeded();
        $this->adjustTrustedHostsPatternIfNeeded();
        $this->executeSilentConfigurationUpgradesIfNeeded();
        $this->initializeSession();
        $this->checkSessionToken();
        $this->checkSessionLifetime();
        $this->loginIfRequested();
        $this->outputLoginFormIfNotAuthorized();
        $this->executeSpecificStep();
        $this->outputSpecificStep();
        $this->redirectToTool();
    }

    protected function executeSpecificStep()
    {
        $action = $this->getAction();
        $postValues = $this->getPostValues();
        if ($action && isset($postValues['set']) && $postValues['set'] === 'execute') {
            $stepAction = $this->getActionInstance($action);
            $stepAction->setAction($action);
            $stepAction->setToken($this->generateTokenForAction($action));
            $stepAction->setPostValues($this->getPostValues());
            $messages = $stepAction->execute();
            $this->addSessionMessages($messages);
            $this->redirect();
        }
    }

    protected function outputSpecificStep()
    {
        $action = $this->getAction();
        if ($action === '') {
            // First step action
            list($action) = $this->authenticationActions;
        }
        $stepAction = $this->getActionInstance($action);
        $stepAction->setAction($action);
        $stepAction->setController('step');
        $stepAction->setToken($this->generateTokenForAction($action));
        $stepAction->setPostValues($this->getPostValues());

        $needsExecution = true;
        try {
            // needsExecution() may throw a RedirectException to communicate that it changed
            // configuration parameters and need an application reload.
            $needsExecution = $stepAction->needsExecution();
        } catch (Exception\RedirectException $e) {
            $this->redirect();
        }

        if ($needsExecution) {
            if ($this->isInitialInstallationInProgress()) {
                $currentStep = (array_search($action, $this->authenticationActions) + 1);
                $totalSteps = count($this->authenticationActions);
                $stepAction->setStepsCounter($currentStep, $totalSteps);
            }
            $stepAction->setMessages($this->session->getMessagesAndFlush());
            $this->output($stepAction->handle());
        } else {
            // Redirect to next step if there are any
            $currentPosition = array_keys($this->authenticationActions, $action, true);
            $nextAction = array_slice($this->authenticationActions, $currentPosition[0] + 1, 1);
            if (!empty($nextAction)) {
                $this->redirect('', $nextAction[0]);
            }
        }
    }

    protected function getActionInstance($action)
    {
        $this->validateAuthenticationAction($action);
        $actionClass = ucfirst($action);
        $stepAction = GeneralUtility::makeInstance('TYPO3\\CMS\\Install\\Controller\\Action\\Step\\' . $actionClass);
        if (!($stepAction instanceof Action\Step\StepInterface)) {
            throw new Exception(
                $action . ' does non implement StepInterface',
                1371303903
            );
        }
        return $stepAction;
    }

    protected function redirectToTool()
    {
        $this->redirect('tool');
    }

    protected function recreatePackageStatesFileIfNotExisting()
    {
        $configurationManager = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Configuration\ConfigurationManager::class);
        $localConfigurationFileLocation = $configurationManager->getLocalConfigurationFileLocation();
        $localConfigurationFileExists = is_file($localConfigurationFileLocation);
        $packageStatesFilePath = PATH_typo3conf . 'PackageStates.php';
        $localConfigurationBackupFilePath = preg_replace(
            '/\\.php$/',
            '.beforePackageStatesMigration.php',
            $configurationManager->getLocalConfigurationFileLocation()
        );

        if (file_exists($packageStatesFilePath)
            || (is_dir(PATH_typo3conf) && !$localConfigurationFileExists)
            || !is_dir(PATH_typo3conf)
        ) {
            return;
        }

        try {
            $packageManager = \TYPO3\CMS\Core\Core\Bootstrap::getInstance()->getEarlyInstance(\TYPO3\CMS\Core\Package\PackageManager::class);

            // Activate all packages required for a minimal usable system
            $packages = $packageManager->getAvailablePackages();
            foreach ($packages as $package) {
                if ($package instanceof \TYPO3\CMS\Core\Package\PackageInterface
                    && $package->isPartOfMinimalUsableSystem()
                ) {
                    $packageManager->activatePackage($package->getPackageKey());
                }
            }

            // Backup LocalConfiguration.php
            copy(
                $configurationManager->getLocalConfigurationFileLocation(),
                $localConfigurationBackupFilePath
            );

            $packageManager->forceSortAndSavePackageStates();

            // Perform a reload to self, so bootstrap now uses new PackageStates.php
            $this->redirect();
        } catch (\Exception $exception) {
            if (file_exists($packageStatesFilePath)) {
                unlink($packageStatesFilePath);
            }
            if (file_exists($localConfigurationBackupFilePath)) {
                unlink($localConfigurationBackupFilePath);
            }
            throw $exception;
        }
    }

    protected function executeOrOutputFirstInstallStepIfNeeded()
    {
        $postValues = $this->getPostValues();

        $wasExecuted = false;
        $errorMessagesFromExecute = [];
        if (isset($postValues['action'])
            && $postValues['action'] === 'environmentAndFolders'
        ) {
            $action = GeneralUtility::makeInstance(\TYPO3\CMS\Install\Controller\Action\Step\EnvironmentAndFolders::class);
            $errorMessagesFromExecute = $action->execute();
            $wasExecuted = true;
        }

        $action = GeneralUtility::makeInstance(\TYPO3\CMS\Install\Controller\Action\Step\EnvironmentAndFolders::class);

        $needsExecution = true;
        try {
            // needsExecution() may throw a RedirectException to communicate that it changed
            // configuration parameters and need an application reload.
            $needsExecution = $action->needsExecution();
        } catch (Exception\RedirectException $e) {
            $this->redirect();
        }

        if (!@is_dir(PATH_typo3conf) || $needsExecution) {
            $action = GeneralUtility::makeInstance(\TYPO3\CMS\Install\Controller\Action\Step\EnvironmentAndFolders::class);
            if ($this->isInitialInstallationInProgress()) {
                $currentStep = (array_search('environmentAndFolders', $this->authenticationActions) + 1);
                $totalSteps = count($this->authenticationActions);
                $action->setStepsCounter($currentStep, $totalSteps);
            }
            $action->setController('step');
            $action->setAction('environmentAndFolders');
            if (!empty($errorMessagesFromExecute)) {
                $action->setMessages($errorMessagesFromExecute);
            }
            $this->output($action->handle());
        }

        if ($wasExecuted) {
            $this->redirect();
        }
    }

    protected function adjustTrustedHostsPatternIfNeeded()
    {
        if (GeneralUtility::hostHeaderValueMatchesTrustedHostsPattern($_SERVER['HTTP_HOST'])) {
            return;
        }

        $configurationManager = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Configuration\ConfigurationManager::class);
        $configurationManager->setLocalConfigurationValueByPath('SYS/trustedHostsPattern', '.*');
        $this->redirect();
    }

    protected function executeSilentConfigurationUpgradesIfNeeded()
    {
        $upgradeService = GeneralUtility::makeInstance(SilentConfigurationUpgradeService::class);
        try {
            $upgradeService->execute();
        } catch (Exception\RedirectException $e) {
            $this->redirect();
        }
    }
}