Installer.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Installer;
 
use Exception;
use ExecutableFinder;
use GuzzleHttp\Psr7\Header;
use IntlChar;
use InvalidArgumentException;
use MediaWiki\Config\Config;
use MediaWiki\Config\GlobalVarConfig;
use MediaWiki\Config\HashConfig;
use MediaWiki\Config\MultiConfig;
use MediaWiki\Context\RequestContext;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\Installer\Task\TaskFactory;
use MediaWiki\Installer\Task\TaskList;
use MediaWiki\Installer\Task\TaskRunner;
use MediaWiki\Language\Language;
use MediaWiki\MainConfigNames;
use MediaWiki\MainConfigSchema;
use MediaWiki\MediaWikiServices;
use MediaWiki\Parser\Parser;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Registration\ExtensionDependencyError;
use MediaWiki\Registration\ExtensionRegistry;
use MediaWiki\Settings\SettingsBuilder;
use MediaWiki\Status\Status;
use MediaWiki\StubObject\StubGlobalUser;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
use MWCryptRand;
use RuntimeException;
use Wikimedia\AtEase\AtEase;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\ObjectCache\EmptyBagOStuff;
use Wikimedia\Services\ServiceDisabledException;
 
abstract class Installer {
 
    protected $settings;
 
    protected $compiledDBs;
 
    protected $dbInstallers = [];
 
    protected $minMemorySize = 50;
 
    protected $parserTitle;
 
    protected $parserOptions;
 
    protected static $dbTypes = [
        'mysql',
        'postgres',
        'sqlite',
    ];
 
    protected $envChecks = [
        'envCheckLibicu',
        'envCheckDB',
        'envCheckPCRE',
        'envCheckMemory',
        'envCheckCache',
        'envCheckModSecurity',
        'envCheckDiff3',
        'envCheckGraphics',
        'envCheckGit',
        'envCheckServer',
        'envCheckPath',
        'envCheckUploadsDirectory',
        'envCheckUploadsServerResponse',
        'envCheck64Bit',
    ];
 
    private const DEFAULT_VAR_NAMES = [
        MainConfigNames::Sitename,
        MainConfigNames::PasswordSender,
        MainConfigNames::LanguageCode,
        MainConfigNames::Localtimezone,
        MainConfigNames::RightsIcon,
        MainConfigNames::RightsText,
        MainConfigNames::RightsUrl,
        MainConfigNames::EnableEmail,
        MainConfigNames::EnableUserEmail,
        MainConfigNames::EnotifUserTalk,
        MainConfigNames::EnotifWatchlist,
        MainConfigNames::EmailAuthentication,
        MainConfigNames::DBname,
        MainConfigNames::DBtype,
        MainConfigNames::Diff3,
        MainConfigNames::ImageMagickConvertCommand,
        MainConfigNames::GitBin,
        MainConfigNames::ScriptPath,
        MainConfigNames::MetaNamespace,
        MainConfigNames::DeletedDirectory,
        MainConfigNames::EnableUploads,
        MainConfigNames::SecretKey,
        MainConfigNames::UseInstantCommons,
        MainConfigNames::UpgradeKey,
        MainConfigNames::DefaultSkin,
        MainConfigNames::Pingback,
        MainConfigNames::InstallerInitialPages,
    ];
 
    protected $internalDefaults = [
        '_UserLang' => 'en',
        '_Environment' => false,
        '_RaiseMemory' => false,
        '_UpgradeDone' => false,
        '_InstallDone' => false,
        '_Caches' => [],
        '_InstallPassword' => '',
        '_SameAccount' => true,
        '_CreateDBAccount' => false,
        '_NamespaceType' => 'site-name',
        '_AdminName' => '', // will be set later, when the user selects language
        '_AdminPassword' => '',
        '_AdminPasswordConfirm' => '',
        '_AdminEmail' => '',
        '_Subscribe' => false,
        '_SkipOptional' => 'continue',
        '_RightsProfile' => 'wiki',
        '_LicenseCode' => 'none',
        '_CCDone' => false,
        '_Extensions' => [],
        '_Skins' => [],
        '_MemCachedServers' => '',
        '_UpgradeKeySupplied' => false,
        '_ExistingDBSettings' => false,
        '_LogoWordmark' => '',
        '_LogoWordmarkWidth' => 119,
        '_LogoWordmarkHeight' => 18,
        // Single quotes are intentional, LocalSettingsGenerator must output this unescaped.
        '_Logo1x' => '$wgResourceBasePath/resources/assets/change-your-logo.svg',
        '_LogoIcon' => '$wgResourceBasePath/resources/assets/change-your-logo-icon.svg',
        '_LogoTagline' => '',
        '_LogoTaglineWidth' => 117,
        '_LogoTaglineHeight' => 13,
        '_WithDevelopmentSettings' => false,
        'wgAuthenticationTokenVersion' => 1,
    ];
 
    protected $extraInstallSteps = [];
 
    protected $objectCaches = [
        'apcu' => 'apcu_fetch',
    ];
 
    public $rightsProfiles = [
        'wiki' => [],
        'no-anon' => [
            '*' => [ 'edit' => false ]
        ],
        'fishbowl' => [
            '*' => [
                'createaccount' => false,
                'edit' => false,
            ],
        ],
        'private' => [
            '*' => [
                'createaccount' => false,
                'edit' => false,
                'read' => false,
            ],
        ],
    ];
 
    public $licenses = [
        'cc-by' => [
            'url' => 'https://creativecommons.org/licenses/by/4.0/',
            'icon' => '$wgResourceBasePath/resources/assets/licenses/cc-by.png',
        ],
        'cc-by-sa' => [
            'url' => 'https://creativecommons.org/licenses/by-sa/4.0/',
            'icon' => '$wgResourceBasePath/resources/assets/licenses/cc-by-sa.png',
        ],
        'cc-by-nc-sa' => [
            'url' => 'https://creativecommons.org/licenses/by-nc-sa/4.0/',
            'icon' => '$wgResourceBasePath/resources/assets/licenses/cc-by-nc-sa.png',
        ],
        'cc-0' => [
            'url' => 'https://creativecommons.org/publicdomain/zero/1.0/',
            'icon' => '$wgResourceBasePath/resources/assets/licenses/cc-0.png',
        ],
        'gfdl' => [
            'url' => 'https://www.gnu.org/copyleft/fdl.html',
            'icon' => '$wgResourceBasePath/resources/assets/licenses/gnu-fdl.png',
        ],
        'none' => [
            'url' => '',
            'icon' => '',
            'text' => ''
        ],
    ];
 
    protected $autoExtensionHookContainer;
    protected array $virtualDomains = [];
 
    private $taskFactory;
 
    abstract public function showMessage( $msg, ...$params );
 
    abstract public function showSuccess( $msg, ...$params );
 
    abstract public function showWarning( $msg, ...$params );
 
    abstract public function showError( $msg, ...$params );
 
    abstract public function showStatusMessage( Status $status );
 
    public static function getInstallerConfig( Config $baseConfig ) {
        $configOverrides = new HashConfig();
 
        // disable (problematic) object cache types explicitly, preserving all other (working) ones
        // bug T113843
        $emptyCache = [ 'class' => EmptyBagOStuff::class ];
 
        $objectCaches = [
                CACHE_NONE => $emptyCache,
                CACHE_DB => $emptyCache,
                CACHE_ANYTHING => $emptyCache,
                CACHE_MEMCACHED => $emptyCache,
            ] + $baseConfig->get( MainConfigNames::ObjectCaches );
 
        $configOverrides->set( MainConfigNames::ObjectCaches, $objectCaches );
 
        $installerConfig = new MultiConfig( [ $configOverrides, $baseConfig ] );
 
        // make sure we use the installer config as the main config
        $configRegistry = $baseConfig->get( MainConfigNames::ConfigRegistry );
        $configRegistry['main'] = static function () use ( $installerConfig ) {
            return $installerConfig;
        };
 
        $configOverrides->set( MainConfigNames::ConfigRegistry, $configRegistry );
 
        return $installerConfig;
    }
 
    public function __construct() {
        $defaultConfig = new GlobalVarConfig(); // all the defaults from config-schema.yaml.
        $installerConfig = self::getInstallerConfig( $defaultConfig );
 
        // Disable all storage services, since we don't have any configuration yet!
        $lang = $this->getVar( '_UserLang', 'en' );
        $services = self::disableStorage( $installerConfig, $lang );
 
        // Set up ParserOptions
        $user = RequestContext::getMain()->getUser();
        $this->parserOptions = new ParserOptions( $user ); // language will be wrong :(
        // Don't try to access DB before user language is initialised
        $this->setParserLanguage( $services->getLanguageFactory()->getLanguage( 'en' ) );
 
        $this->settings = $this->getDefaultSettings();
 
        $this->compiledDBs = [];
        foreach ( self::getDBTypes() as $type ) {
            $installer = $this->getDBInstaller( $type );
 
            if ( !$installer->isCompiled() ) {
                continue;
            }
            $this->compiledDBs[] = $type;
        }
 
        $this->parserTitle = Title::newFromText( 'Installer' );
    }
 
    private function getDefaultSettings(): array {
        global $wgLocaltimezone;
 
        $ret = $this->internalDefaults;
 
        foreach ( self::DEFAULT_VAR_NAMES as $name ) {
            $var = "wg{$name}";
            $ret[$var] = MainConfigSchema::getDefaultValue( $name );
        }
 
        // Set $wgLocaltimezone to the value of the global, which SetupDynamicConfig.php will have
        // set to something that is a valid timezone.
        $ret['wgLocaltimezone'] = $wgLocaltimezone;
 
        // Detect $wgServer
        $server = $this->envGetDefaultServer();
        if ( $server !== null ) {
            $ret['wgServer'] = $server;
        }
 
        // Detect $IP
        $ret['IP'] = MW_INSTALL_PATH;
 
        return $this->getDefaultSettingsOverrides()
            + $this->generateKeys()
            + $this->detectWebPaths()
            + $ret;
    }
 
    protected function detectWebPaths() {
        return [];
    }
 
    protected function getDefaultSettingsOverrides() {
        return [];
    }
 
    private function generateKeys() {
        $keyLengths = [
            'wgSecretKey' => 64,
            'wgUpgradeKey' => 16,
        ];
 
        $keys = [];
        foreach ( $keyLengths as $name => $length ) {
            $keys[$name] = MWCryptRand::generateHex( $length );
        }
        return $keys;
    }
 
    public static function disableStorage( Config $config, string $lang ) {
        global $wgObjectCaches, $wgLang;
 
        // Reset all services and inject config overrides.
        // Reload to re-enable Rdbms, in case of any prior MediaWikiServices::disableStorage()
        MediaWikiServices::resetGlobalInstance( $config, 'reload' );
 
        $mwServices = MediaWikiServices::getInstance();
        $mwServices->disableStorage();
 
        // Disable i18n cache
        $mwServices->getLocalisationCache()->disableBackend();
 
        // Set a fake user.
        // Note that this will reset the context's language,
        // so set the user before setting the language.
        $user = User::newFromId( 0 );
        StubGlobalUser::setUser( $user );
 
        RequestContext::getMain()->setUser( $user );
 
        // Don't attempt to load user language options (T126177)
        // This will be overridden in the web installer with the user-specified language
        // Ensure $wgLang does not have a reference to a stale LocalisationCache instance
        // (T241638, T261081)
        RequestContext::getMain()->setLanguage( $lang );
        $wgLang = RequestContext::getMain()->getLanguage();
 
        // Disable object cache (otherwise CACHE_ANYTHING will try CACHE_DB and
        // SqlBagOStuff will then throw since we just disabled database connections)
        $wgObjectCaches = $mwServices->getMainConfig()->get( MainConfigNames::ObjectCaches );
        return $mwServices;
    }
 
    public static function getDBTypes() {
        return self::$dbTypes;
    }
 
    public function doEnvironmentChecks() {
        // PHP version has already been checked by entry scripts
        // Show message here for information purposes
        $this->showMessage( 'config-env-php', PHP_VERSION );
 
        $good = true;
        foreach ( $this->envChecks as $check ) {
            $status = $this->$check();
            if ( $status === false ) {
                $good = false;
            }
        }
 
        $this->setVar( '_Environment', $good );
 
        return $good ? Status::newGood() : Status::newFatal( 'config-env-bad' );
    }
 
    public function setVar( $name, $value ) {
        $this->settings[$name] = $value;
    }
 
    public function getVar( $name, $default = null ) {
        return $this->settings[$name] ?? $default;
    }
 
    public function getCompiledDBs() {
        return $this->compiledDBs;
    }
 
    public static function getDBInstallerClass( $type ) {
        return '\\MediaWiki\\Installer\\' . ucfirst( $type ) . 'Installer';
    }
 
    public function getDBInstaller( $type = false ) {
        if ( !$type ) {
            $type = $this->getVar( 'wgDBtype' );
        }
 
        $type = strtolower( $type );
 
        if ( !isset( $this->dbInstallers[$type] ) ) {
            $class = self::getDBInstallerClass( $type );
            $this->dbInstallers[$type] = new $class( $this );
        }
 
        return $this->dbInstallers[$type];
    }
 
    public static function getExistingLocalSettings() {
        $IP = wfDetectInstallPath();
 
        // You might be wondering why this is here. Well if you don't do this
        // then some poorly-formed extensions try to call their own classes
        // after immediately registering them. We really need to get extension
        // registration out of the global scope and into a real format.
        // @see https://phabricator.wikimedia.org/T69440
        global $wgAutoloadClasses;
        $wgAutoloadClasses = [];
 
        // LocalSettings.php should not call functions, except wfLoadSkin/wfLoadExtensions
        // Define the required globals here, to ensure, the functions can do it work correctly.
        // phpcs:ignore MediaWiki.VariableAnalysis.UnusedGlobalVariables
        global $wgExtensionDirectory, $wgStyleDirectory;
 
        // This will also define MW_CONFIG_FILE
        $lsFile = wfDetectLocalSettingsFile( $IP );
        // phpcs:ignore Generic.PHP.NoSilencedErrors
        $lsExists = @file_exists( $lsFile );
 
        if ( !$lsExists ) {
            return false;
        }
 
        if ( !str_ends_with( $lsFile, '.php' ) ) {
            throw new RuntimeException(
                'The installer cannot yet handle non-php settings files: ' . $lsFile . '. ' .
                'Use `php maintenance/run.php update` to update an existing installation.'
            );
        }
        unset( $lsExists );
 
        // Extract the defaults into the current scope
        foreach ( MainConfigSchema::listDefaultValues( 'wg' ) as $var => $value ) {
            $$var = $value;
        }
 
        $wgExtensionDirectory = "$IP/extensions";
        $wgStyleDirectory = "$IP/skins";
 
        // Non-config globals available to LocalSettings
        //
        // NOTE: Keep in sync with LocalSettingsLoader, normally called from Setup.php
        //
        // phpcs:ignore MediaWiki.VariableAnalysis.UnusedGlobalVariables, MediaWiki.Usage.DeprecatedGlobalVariables
        global $wgCommandLineMode, $wgConf;
 
        // NOTE: To support YAML settings files, this needs to start using SettingsBuilder.
        //       However, as of 1.38, YAML settings files are still experimental and
        //       SettingsBuilder is still unstable. For now, the installer will fail if
        //       the existing settings file is not PHP. The updater should still work though.
        // NOTE: When adding support for YAML settings file, all references to LocalSettings.php
        //       in localisation messages need to be replaced.
        // NOTE: This assumes simple variable assignments. More complex setups may involve
        //       settings coming from sub-required and/or functions that assign globals
        //       directly. This is fine here because this isn't used as the "real" include.
        //       It is only used for reading out a small set of variables that the installer
        //       validates and/or displays.
        require $lsFile;
 
        return get_defined_vars();
    }
 
    public function getFakePassword( $realPassword ) {
        return str_repeat( '*', strlen( $realPassword ) );
    }
 
    public function setPassword( $name, $value ) {
        if ( !preg_match( '/^\*+$/', $value ) ) {
            $this->setVar( $name, $value );
        }
    }
 
    public function parse( $text, $lineStart = false ) {
        $parser = MediaWikiServices::getInstance()->getParser();
 
        try {
            $out = $parser->parse( $text, $this->parserTitle, $this->parserOptions, $lineStart );
            $pipeline = MediaWikiServices::getInstance()->getDefaultOutputPipeline();
            // TODO T371008 consider if using the Content framework makes sense instead of creating the pipeline
            $html = $pipeline->run( $out, $this->parserOptions, [
                'enableSectionEditLinks' => false,
                'unwrap' => true,
            ] )->getContentHolderText();
            $html = Parser::stripOuterParagraph( $html );
        } catch ( ServiceDisabledException ) {
            $html = '<!--DB access attempted during parse-->  ' . htmlspecialchars( $text );
        }
 
        return $html;
    }
 
    public function getParserOptions() {
        return $this->parserOptions;
    }
 
    public function disableLinkPopups() {
        // T317647: This ParserOptions method is deprecated; we should be
        // updating ExternalLinkTarget in the Configuration instead.
        $this->parserOptions->setExternalLinkTarget( false );
    }
 
    public function restoreLinkPopups() {
        // T317647: This ParserOptions method is deprecated; we should be
        // updating ExternalLinkTarget in the Configuration instead.
        global $wgExternalLinkTarget;
        $this->parserOptions->setExternalLinkTarget( $wgExternalLinkTarget );
    }
 
    protected function envCheckDB() {
        global $wgLang;
        $dbType = $this->getVar( 'wgDBtype' );
 
        $allNames = [];
 
        // Messages: config-type-mysql, config-type-postgres, config-type-sqlite
        foreach ( self::getDBTypes() as $name ) {
            $allNames[] = wfMessage( "config-type-$name" )->text();
        }
 
        $databases = $this->getCompiledDBs();
 
        $databases = array_flip( $databases );
        $ok = true;
        foreach ( $databases as $db => $_ ) {
            $installer = $this->getDBInstaller( $db );
            $status = $installer->checkPrerequisites();
            if ( !$status->isGood() ) {
                if ( !$this instanceof WebInstaller && $db === $dbType ) {
                    // Strictly check the key database type instead of just outputting message
                    // Note: No perform this check run from the web installer, since this method always called by
                    // the welcome page under web installation, so $dbType will always be 'mysql'
                    $ok = false;
                }
                $this->showStatusMessage( $status );
                unset( $databases[$db] );
            }
        }
        $databases = array_flip( $databases );
        if ( !$databases ) {
            $this->showError( 'config-no-db', $wgLang->commaList( $allNames ), count( $allNames ) );
            return false;
        }
        return $ok;
    }
 
    protected function envCheckPCRE() {
        // PCRE2 must be compiled using NEWLINE_DEFAULT other than 4 (ANY);
        // otherwise, it will misidentify UTF-8 trailing byte value 0x85
        // as a line ending character when in non-UTF mode.
        if ( preg_match( '/^b.*c$/', 'bąc' ) === 0 ) {
            $this->showError( 'config-pcre-invalid-newline' );
            return false;
        }
        return true;
    }
 
    protected function envCheckMemory() {
        $limit = ini_get( 'memory_limit' );
 
        if ( !$limit || $limit == -1 ) {
            return true;
        }
 
        $n = wfShorthandToInteger( $limit );
 
        if ( $n < $this->minMemorySize * 1024 * 1024 ) {
            $newLimit = "{$this->minMemorySize}M";
 
            if ( ini_set( "memory_limit", $newLimit ) === false ) {
                $this->showMessage( 'config-memory-bad', $limit );
            } else {
                $this->showMessage( 'config-memory-raised', $limit, $newLimit );
                $this->setVar( '_RaiseMemory', true );
            }
        }
 
        return true;
    }
 
    protected function envCheckCache() {
        $caches = [];
        foreach ( $this->objectCaches as $name => $function ) {
            if ( function_exists( $function ) ) {
                $caches[$name] = true;
            }
        }
 
        if ( !$caches ) {
            $this->showMessage( 'config-no-cache-apcu' );
        }
 
        $this->setVar( '_Caches', $caches );
    }
 
    protected function envCheckModSecurity() {
        if ( self::apacheModulePresent( 'mod_security' )
            || self::apacheModulePresent( 'mod_security2' ) ) {
            $this->showMessage( 'config-mod-security' );
        }
 
        return true;
    }
 
    protected function envCheckDiff3() {
        $names = [ "gdiff3", "diff3" ];
        if ( wfIsWindows() ) {
            $names[] = 'diff3.exe';
        }
        $versionInfo = [ '--version', 'GNU diffutils' ];
 
        $diff3 = ExecutableFinder::findInDefaultPaths( $names, $versionInfo );
 
        if ( $diff3 ) {
            $this->setVar( 'wgDiff3', $diff3 );
        } else {
            $this->setVar( 'wgDiff3', false );
            $this->showMessage( 'config-diff3-bad' );
        }
 
        return true;
    }
 
    protected function envCheckGraphics() {
        $names = wfIsWindows() ? 'convert.exe' : 'convert';
        $versionInfo = [ '-version', 'ImageMagick' ];
        $convert = ExecutableFinder::findInDefaultPaths( $names, $versionInfo );
 
        $this->setVar( 'wgImageMagickConvertCommand', '' );
        if ( $convert ) {
            $this->setVar( 'wgImageMagickConvertCommand', $convert );
            $this->showMessage( 'config-imagemagick', $convert );
        } elseif ( function_exists( 'imagejpeg' ) ) {
            $this->showMessage( 'config-gd' );
        } else {
            $this->showMessage( 'config-no-scaling' );
        }
 
        return true;
    }
 
    protected function envCheckGit() {
        $names = wfIsWindows() ? 'git.exe' : 'git';
        $versionInfo = [ '--version', 'git version' ];
 
        $git = ExecutableFinder::findInDefaultPaths( $names, $versionInfo );
 
        if ( $git ) {
            $this->setVar( 'wgGitBin', $git );
            $this->showMessage( 'config-git', $git );
        } else {
            $this->setVar( 'wgGitBin', false );
            $this->showMessage( 'config-git-bad' );
        }
 
        return true;
    }
 
    protected function envCheckServer() {
        $server = $this->envGetDefaultServer();
        if ( $server !== null ) {
            $this->showMessage( 'config-using-server', $server );
        }
        return true;
    }
 
    protected function envCheckPath() {
        $this->showMessage(
            'config-using-uri',
            $this->getVar( 'wgServer' ),
            $this->getVar( 'wgScriptPath' )
        );
        return true;
    }
 
    protected function envCheckUploadsDirectory() {
        global $IP;
 
        $dir = $IP . '/images/';
        $url = $this->getVar( 'wgServer' ) . $this->getVar( 'wgScriptPath' ) . '/images/';
        $safe = !$this->dirIsExecutable( $dir, $url );
 
        if ( !$safe ) {
            $this->showWarning( 'config-uploads-not-safe', $dir );
        }
 
        return true;
    }
 
    protected function envCheckUploadsServerResponse(): bool {
        $url = $this->getVar( 'wgServer' ) . $this->getVar( 'wgScriptPath' ) . '/images/README';
        $httpRequestFactory = MediaWikiServices::getInstance()->getHttpRequestFactory();
        $status = null;
 
        $req = $httpRequestFactory->create(
            $url,
            [
                'method' => 'GET',
                'timeout' => 3,
                'followRedirects' => true
            ],
            __METHOD__
        );
        try {
            $status = $req->execute();
        } catch ( Exception ) {
            // HttpRequestFactory::get can throw with allow_url_fopen = false and no curl
            // extension.
        }
 
        if ( !$status || !$status->isGood() ) {
            $this->showWarning( 'config-uploads-security-requesterror', 'X-Content-Type-Options: nosniff' );
            return true;
        }
 
        $headerValue = $req->getResponseHeader( 'X-Content-Type-Options' ) ?? '';
        $responseList = Header::splitList( $headerValue );
        if ( !in_array( 'nosniff', $responseList, true ) ) {
            $this->showWarning( 'config-uploads-security-headers', 'X-Content-Type-Options: nosniff' );
        }
 
        return true;
    }
 
    protected function envCheck64Bit() {
        if ( PHP_INT_SIZE == 4 ) {
            $this->showMessage( 'config-using-32bit' );
        }
 
        return true;
    }
 
    protected function envCheckLibicu() {
        $unicodeVersion = implode( '.', array_slice( IntlChar::getUnicodeVersion(), 0, 3 ) );
        $this->showMessage( 'config-env-icu', INTL_ICU_VERSION, $unicodeVersion );
    }
 
    abstract protected function envGetDefaultServer();
 
    public function dirIsExecutable( $dir, $url ) {
        $scriptTypes = [
            'php' => [
                "<?php echo 'exec';",
                "#!/var/env php\n<?php echo 'exec';",
            ],
        ];
 
        // it would be good to check other popular languages here, but it'll be slow.
        // TODO no need to have a loop if there is going to only be one script type
 
        $httpRequestFactory = MediaWikiServices::getInstance()->getHttpRequestFactory();
 
        AtEase::suppressWarnings();
 
        foreach ( $scriptTypes as $ext => $contents ) {
            foreach ( $contents as $source ) {
                $file = 'exectest.' . $ext;
 
                if ( !file_put_contents( $dir . $file, $source ) ) {
                    break;
                }
 
                try {
                    $text = $httpRequestFactory->get(
                        $url . $file,
                        [ 'timeout' => 3 ],
                        __METHOD__
                    );
                } catch ( Exception ) {
                    // HttpRequestFactory::get can throw with allow_url_fopen = false and no curl
                    // extension.
                    $text = null;
                }
                unlink( $dir . $file );
 
                if ( $text == 'exec' ) {
                    AtEase::restoreWarnings();
 
                    return $ext;
                }
            }
        }
 
        AtEase::restoreWarnings();
 
        return false;
    }
 
    public static function apacheModulePresent( $moduleName ) {
        if ( function_exists( 'apache_get_modules' ) && in_array( $moduleName, apache_get_modules() ) ) {
            return true;
        }
        // try it the hard way
        ob_start();
        phpinfo( INFO_MODULES );
        $info = ob_get_clean();
 
        return str_contains( $info, $moduleName );
    }
 
    public function setParserLanguage( $lang ) {
        $this->parserOptions->setTargetLanguage( $lang );
        $this->parserOptions->setUserLang( $lang );
    }
 
    protected function getDocUrl( $page ) {
        return "{$_SERVER['PHP_SELF']}?page=" . urlencode( $page );
    }
 
    public function findExtensions( $directory = 'extensions' ) {
        switch ( $directory ) {
            case 'extensions':
                return $this->findExtensionsByType( 'extension', 'extensions' );
            case 'skins':
                return $this->findExtensionsByType( 'skin', 'skins' );
            default:
                throw new InvalidArgumentException( "Invalid extension type" );
        }
    }
 
    protected function findExtensionsByType( $type = 'extension', $directory = 'extensions' ) {
        if ( $this->getVar( 'IP' ) === null ) {
            return Status::newGood( [] );
        }
 
        $extDir = $this->getVar( 'IP' ) . '/' . $directory;
        if ( !is_readable( $extDir ) || !is_dir( $extDir ) ) {
            return Status::newGood( [] );
        }
 
        $dh = opendir( $extDir );
        $exts = [];
        $status = new Status;
        // phpcs:ignore Generic.CodeAnalysis.AssignmentInCondition.FoundInWhileCondition
        while ( ( $file = readdir( $dh ) ) !== false ) {
            // skip non-dirs and hidden directories
            if ( !is_dir( "$extDir/$file" ) || $file[0] === '.' ) {
                continue;
            }
            $extStatus = $this->getExtensionInfo( $type, $directory, $file );
            if ( $extStatus->isOK() ) {
                $exts[$file] = $extStatus->value;
            } elseif ( $extStatus->hasMessage( 'config-extension-not-found' ) ) {
                // (T225512) The directory is not actually an extension. Downgrade to warning.
                $status->warning( 'config-extension-not-found', $file );
            } else {
                $status->merge( $extStatus );
            }
        }
        closedir( $dh );
        uksort( $exts, 'strnatcasecmp' );
 
        $status->value = $exts;
 
        return $status;
    }
 
    protected function getExtensionInfo( $type, $parentRelPath, $name ) {
        if ( $this->getVar( 'IP' ) === null ) {
            throw new RuntimeException( 'Cannot find extensions since the IP variable is not yet set' );
        }
        if ( $type !== 'extension' && $type !== 'skin' ) {
            throw new InvalidArgumentException( "Invalid extension type" );
        }
        $absDir = $this->getVar( 'IP' ) . "/$parentRelPath/$name";
        $relDir = "../$parentRelPath/$name";
        if ( !is_dir( $absDir ) ) {
            return Status::newFatal( 'config-extension-not-found', $name );
        }
        $jsonFile = $type . '.json';
        $fullJsonFile = "$absDir/$jsonFile";
        $isJson = file_exists( $fullJsonFile );
        $isPhp = false;
        if ( !$isJson ) {
            // Only fallback to PHP file if JSON doesn't exist
            $fullPhpFile = "$absDir/$name.php";
            $isPhp = file_exists( $fullPhpFile );
        }
        if ( !$isJson && !$isPhp ) {
            return Status::newFatal( 'config-extension-not-found', $name );
        }
 
        // Extension exists. Now see if there are screenshots
        $info = [];
        if ( is_dir( "$absDir/screenshots" ) ) {
            $paths = glob( "$absDir/screenshots/*.png" );
            foreach ( $paths as $path ) {
                $info['screenshots'][] = str_replace( $absDir, $relDir, $path );
            }
        }
 
        if ( $isJson ) {
            $jsonStatus = $this->readExtension( $fullJsonFile );
            if ( !$jsonStatus->isOK() ) {
                return $jsonStatus;
            }
            $info += $jsonStatus->value;
        }
 
        return Status::newGood( $info );
    }
 
    private function readExtension( $fullJsonFile, $extDeps = [], $skinDeps = [] ) {
        $load = [
            $fullJsonFile => 1
        ];
        if ( $extDeps ) {
            $extDir = $this->getVar( 'IP' ) . '/extensions';
            foreach ( $extDeps as $dep ) {
                $fname = "$extDir/$dep/extension.json";
                if ( !file_exists( $fname ) ) {
                    return Status::newFatal( 'config-extension-not-found', $dep );
                }
                $load[$fname] = 1;
            }
        }
        if ( $skinDeps ) {
            $skinDir = $this->getVar( 'IP' ) . '/skins';
            foreach ( $skinDeps as $dep ) {
                $fname = "$skinDir/$dep/skin.json";
                if ( !file_exists( $fname ) ) {
                    return Status::newFatal( 'config-extension-not-found', $dep );
                }
                $load[$fname] = 1;
            }
        }
        $registry = new ExtensionRegistry();
        try {
            $info = $registry->readFromQueue( $load );
        } catch ( ExtensionDependencyError $e ) {
            if ( $e->incompatibleCore || $e->incompatibleSkins
                || $e->incompatibleExtensions
            ) {
                // If something is incompatible with a dependency, we have no real
                // option besides skipping it
                return Status::newFatal( 'config-extension-dependency',
                    basename( dirname( $fullJsonFile ) ), $e->getMessage() );
            } elseif ( $e->missingExtensions || $e->missingSkins ) {
                // There's an extension missing in the dependency tree,
                // so add those to the dependency list and try again
                $status = $this->readExtension(
                    $fullJsonFile,
                    array_merge( $extDeps, $e->missingExtensions ),
                    array_merge( $skinDeps, $e->missingSkins )
                );
                if ( !$status->isOK() && !$status->hasMessage( 'config-extension-dependency' ) ) {
                    $status = Status::newFatal( 'config-extension-dependency',
                        basename( dirname( $fullJsonFile ) ), $status->getMessage() );
                }
                return $status;
            }
            // Some other kind of dependency error?
            return Status::newFatal( 'config-extension-dependency',
                basename( dirname( $fullJsonFile ) ), $e->getMessage() );
        }
        $ret = [];
        // The order of credits will be the order of $load,
        // so the first extension is the one we want to load,
        // everything else is a dependency
        $i = 0;
        foreach ( $info['credits'] as $credit ) {
            $i++;
            if ( $i == 1 ) {
                // Extension we want to load
                continue;
            }
            $type = basename( $credit['path'] ) === 'skin.json' ? 'skins' : 'extensions';
            $ret['requires'][$type][] = $credit['name'];
        }
        $credits = array_values( $info['credits'] )[0];
        if ( isset( $credits['url'] ) ) {
            $ret['url'] = $credits['url'];
        }
        $ret['type'] = $credits['type'];
 
        return Status::newGood( $ret );
    }
 
    public function getDefaultSkin( array $skinNames ) {
        $defaultSkin = $GLOBALS['wgDefaultSkin'];
 
        if ( in_array( 'vector', $skinNames ) ) {
            $skinNames[] = 'vector-2022';
        }
 
        // T346332: Minerva skin uses different name from its directory name
        if ( in_array( 'minervaneue', $skinNames ) ) {
            $minervaNeue = array_search( 'minervaneue', $skinNames );
            $skinNames[$minervaNeue] = 'minerva';
        }
 
        if ( !$skinNames || in_array( $defaultSkin, $skinNames ) ) {
            return $defaultSkin;
        } else {
            return $skinNames[0];
        }
    }
 
    protected function getTaskList() {
        $taskList = new TaskList;
        $taskFactory = $this->getTaskFactory();
        $taskFactory->registerMainTasks( $taskList, TaskFactory::PROFILE_INSTALLER );
 
        // Add any steps added by overrides
        foreach ( $this->extraInstallSteps as $requirement => $steps ) {
            foreach ( $steps as $spec ) {
                if ( $requirement !== 'BEGINNING' ) {
                    $spec += [ 'after' => $requirement ];
                }
                $taskList->add( $taskFactory->create( $spec ) );
            }
        }
 
        return $taskList;
    }
 
    protected function getTaskFactory(): TaskFactory {
        if ( $this->taskFactory === null ) {
            $this->taskFactory = new TaskFactory(
                MediaWikiServices::getInstance()->getObjectFactory(),
                $this->getDBInstaller()
            );
        }
        return $this->taskFactory;
    }
 
    public function performInstallation( $startCB, $endCB ) {
        $tasks = $this->getTaskList();
 
        $taskRunner = new TaskRunner( $tasks, $this->getTaskFactory(),
            TaskFactory::PROFILE_INSTALLER );
        $taskRunner->addTaskStartListener( $startCB );
        $taskRunner->addTaskEndListener( $endCB );
 
        $status = $taskRunner->execute();
        if ( $status->isOK() ) {
            $this->showSuccess(
                'config-install-db-success'
            );
            $this->setVar( '_InstallDone', true );
        }
 
        return $status;
    }
 
    public static function overrideConfig( SettingsBuilder $settings ) {
        // Use PHP's built-in session handling, since MediaWiki's
        // SessionHandler can't work before we have an object cache set up.
        if ( !defined( 'MW_NO_SESSION_HANDLER' ) ) {
            define( 'MW_NO_SESSION_HANDLER', 1 );
        }
 
        $settings->overrideConfigValues( [
 
            // Don't access the database
            MainConfigNames::UseDatabaseMessages => false,
 
            // Don't cache langconv tables
            MainConfigNames::LanguageConverterCacheType => CACHE_NONE,
 
            // Debug-friendly
            MainConfigNames::ShowExceptionDetails => true,
            MainConfigNames::ShowHostnames => true,
 
            // Don't break forms
            MainConfigNames::ExternalLinkTarget => '_blank',
 
            // Allow multiple ob_flush() calls
            MainConfigNames::DisableOutputCompression => true,
 
            // Use a sensible cookie prefix (not my_wiki)
            MainConfigNames::CookiePrefix => 'mw_installer',
 
            // Some of the environment checks make shell requests, remove limits
            MainConfigNames::MaxShellMemory => 0,
 
            // Override the default CookieSessionProvider with a dummy
            // implementation that won't stomp on PHP's cookies.
            MainConfigNames::SessionProviders => [
                [
                    'class' => InstallerSessionProvider::class,
                    'args' => [ [
                        'priority' => 1,
                    ] ]
                ],
            ],
 
            // Don't use the DB as the main stash
            MainConfigNames::MainStash => CACHE_NONE,
 
            // Don't try to use any object cache for SessionManager either.
            MainConfigNames::SessionCacheType => CACHE_NONE,
 
            // Set a dummy $wgServer to bypass the check in Setup.php, the
            // web installer will automatically detect it and not use this value.
            MainConfigNames::Server => 'https://🌻.invalid',
        ] );
    }
 
    public function addInstallStep( $callback, $findStep = 'BEGINNING' ) {
        $this->extraInstallSteps[$findStep][] = $callback;
    }
 
    protected function disableTimeLimit() {
        AtEase::suppressWarnings();
        set_time_limit( 0 );
        AtEase::restoreWarnings();
    }
}