Setup.php

Go to the documentation of this file.

<?php
// phpcs:disable MediaWiki.Usage.DeprecatedGlobalVariables
use MediaWiki\Config\SiteConfiguration;
use MediaWiki\Context\RequestContext;
use MediaWiki\Debug\MWDebug;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\Exception\FatalError;
use MediaWiki\Exception\HttpError;
use MediaWiki\Exception\MWExceptionHandler;
use MediaWiki\Exception\MWExceptionRenderer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Language\Language;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MainConfigSchema;
use MediaWiki\MediaWikiServices;
use MediaWiki\Message\Message;
use MediaWiki\Registration\ExtensionRegistry;
use MediaWiki\Registration\MissingExtensionException;
use MediaWiki\Request\HeaderCallback;
use MediaWiki\Settings\DynamicDefaultValues;
use MediaWiki\Settings\LocalSettingsLoader;
use MediaWiki\Settings\SettingsBuilder;
use MediaWiki\Settings\Source\PhpSettingsSource;
use MediaWiki\Settings\Source\ReflectionSchemaSource;
use MediaWiki\Settings\WikiFarmSettingsLoader;
use MediaWiki\StubObject\StubGlobalUser;
use MediaWiki\StubObject\StubUserLang;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
use Psr\Log\LoggerInterface;
use Wikimedia\Http\HttpStatus;
use Wikimedia\RequestTimeout\RequestTimeout;
use Wikimedia\Telemetry\SpanInterface;
use Wikimedia\Telemetry\TracerState;
 
// This file must be included from a valid entry point (e.g. WebStart.php, Maintenance.php)
if ( !defined( 'MEDIAWIKI' ) ) {
    exit( 1 );
}
 
// The MW_ENTRY_POINT constant must always exists, to make it safe to access.
// For compat, we do support older and custom MW entrypoints that don't set this,
// in which case we assign a default here.
if ( !defined( 'MW_ENTRY_POINT' ) ) {
    define( 'MW_ENTRY_POINT', 'unknown' );
}
 
// The $IP variable is defined for use by LocalSettings.php.
// It is made available as a global variable for backwards compatibility.
//
// Source code should use the MW_INSTALL_PATH constant instead.
global $IP;
$IP = wfDetectInstallPath(); // ensures MW_INSTALL_PATH is defined
 
require_once MW_INSTALL_PATH . '/includes/AutoLoader.php';
require_once MW_INSTALL_PATH . '/includes/Defines.php';
 
// Assert that composer dependencies were successfully loaded
if ( !interface_exists( LoggerInterface::class ) ) {
    $message = (
        '<strong>Error: Missing external libraries.</strong> ' .
        'MediaWiki depends on external libraries bundled with most MediaWiki distributions. ' .
        "When installing MediaWiki from its Git reposistory, these must be installed separately.\n\n" .
        'Please see the <a href="https://www.mediawiki.org/wiki/Download_from_Git' .
        '#Fetch_external_libraries">instructions for installing libraries</a> on mediawiki.org ' .
        'for help on installing the required libraries.'
    );
    http_response_code( 500 );
    echo $message;
    error_log( $message );
    exit( 1 );
}
 
// Deprecated global variable for backwards-compatibility.
// New code should check MW_ENTRY_POINT directly.
$wgCommandLineMode = MW_ENTRY_POINT === 'cli';
 
$wgConf = new SiteConfiguration;
 
$wgAutoloadClasses ??= [];
 
$wgSettings = SettingsBuilder::getInstance();
 
if ( defined( 'MW_USE_CONFIG_SCHEMA_CLASS' ) ) {
    // Load config schema from MainConfigSchema. Useful for running scripts that
    // generate other representations of the config schema. This is slow, so it
    // should not be used for serving web traffic.
    $wgSettings->load( new ReflectionSchemaSource( MainConfigSchema::class ) );
} else {
    $wgSettings->load( new PhpSettingsSource( MW_INSTALL_PATH . '/includes/config-schema.php' ) );
}
 
require_once MW_INSTALL_PATH . '/includes/GlobalFunctions.php';
 
// Install callback for normalizing headers.
HeaderCallback::register();
 
// Tell HttpStatus to use HeaderCallback for reporting warnings when
// attempting to set headers after the headers have already been sent.
HttpStatus::registerHeadersSentCallback(
    [ HeaderCallback::class, 'warnIfHeadersSent' ]
);
 
// Set the encoding used by PHP for reading HTTP input, and writing output.
// This is also the default for mbstring functions.
mb_internal_encoding( 'UTF-8' );
 
// Initialize some config settings with dynamic defaults, and
// make default settings available in globals for use in LocalSettings.php.
$wgSettings->putConfigValues( [
    MainConfigNames::ExtensionDirectory => MW_INSTALL_PATH . '/extensions',
    MainConfigNames::StyleDirectory => MW_INSTALL_PATH . '/skins',
    MainConfigNames::UploadDirectory => MW_INSTALL_PATH . '/images',
    MainConfigNames::ServiceWiringFiles => [ MW_INSTALL_PATH . '/includes/ServiceWiring.php' ],
    'Version' => MW_VERSION,
] );
$wgSettings->apply();
 
// $wgSettings->apply() puts all configuration into global variables.
// If we are not in global scope, make all relevant globals available
// in this file's scope as well.
$wgScopeTest = 'MediaWiki Setup.php scope test';
if ( !isset( $GLOBALS['wgScopeTest'] ) || $GLOBALS['wgScopeTest'] !== $wgScopeTest ) {
    foreach ( $wgSettings->getConfigSchema()->getDefinedKeys() as $key ) {
        $var = "wg$key";
        // phpcs:ignore MediaWiki.NamingConventions.ValidGlobalName.allowedPrefix
        global $$var;
    }
    unset( $key, $var );
}
unset( $wgScopeTest );
 
try {
    if ( defined( 'MW_CONFIG_CALLBACK' ) ) {
        call_user_func( MW_CONFIG_CALLBACK, $wgSettings );
    } else {
        wfDetectLocalSettingsFile( MW_INSTALL_PATH );
 
        if ( getenv( 'MW_USE_LOCAL_SETTINGS_LOADER' ) ) {
            // NOTE: This will not work for configuration variables that use a prefix
            //       other than "wg".
            $localSettingsLoader = new LocalSettingsLoader( $wgSettings, MW_INSTALL_PATH );
            $localSettingsLoader->loadLocalSettingsFile( MW_CONFIG_FILE );
            unset( $localSettingsLoader );
        } else {
            if ( str_ends_with( MW_CONFIG_FILE, '.php' ) ) {
                // make defaults available as globals
                $wgSettings->apply();
                require_once MW_CONFIG_FILE;
            } else {
                $wgSettings->loadFile( MW_CONFIG_FILE );
            }
        }
    }
 
    // Make settings loaded by LocalSettings.php available in globals for use here
    $wgSettings->apply();
} catch ( MissingExtensionException $e ) {
    // Make a common mistake give a friendly error
    $e->render();
}
 
// If in a wiki-farm, load site-specific settings
if ( $wgSettings->getConfig()->get( MainConfigNames::WikiFarmSettingsDirectory ) ) {
    $wikiFarmSettingsLoader = new WikiFarmSettingsLoader( $wgSettings );
    $wikiFarmSettingsLoader->loadWikiFarmSettings();
    unset( $wikiFarmSettingsLoader );
}
 
// All settings should be loaded now.
$wgSettings->enterRegistrationStage();
 
if ( defined( 'MW_SETUP_CALLBACK' ) ) {
    call_user_func( MW_SETUP_CALLBACK, $wgSettings );
    // Make any additional settings available in globals for use here
    $wgSettings->apply();
}
 
// Apply dynamic defaults declared in config schema callbacks.
$dynamicDefaults = new DynamicDefaultValues( $wgSettings->getConfigSchema() );
$dynamicDefaults->applyDynamicDefaults( $wgSettings->getConfigBuilder() );
 
// Make updated config available in global scope.
$wgSettings->apply();
 
// Apply dynamic defaults implemented in SetupDynamicConfig.php.
// Ideally, all logic in SetupDynamicConfig would be converted to
// callbacks in the config schema.
require __DIR__ . '/SetupDynamicConfig.php';
 
if ( defined( 'MW_AUTOLOAD_TEST_CLASSES' ) ) {
    require_once __DIR__ . '/../tests/common/TestsAutoLoader.php';
}
 
// Start time limit
if ( $wgRequestTimeLimit && MW_ENTRY_POINT !== 'cli' ) {
    RequestTimeout::singleton()->setWallTimeLimit( $wgRequestTimeLimit );
}
 
if ( defined( 'MW_AUTOLOAD_TEST_CLASSES' ) ) {
    ExtensionRegistry::getInstance()->setLoadTestClassesAndNamespaces( true );
}
 
ExtensionRegistry::getInstance()->setSettingsBuilder( $wgSettings );
ExtensionRegistry::getInstance()->loadFromQueue();
// Don't let any other extensions load
ExtensionRegistry::getInstance()->finish();
 
if ( defined( 'MW_FINAL_SETUP_CALLBACK' ) ) {
    call_user_func( MW_FINAL_SETUP_CALLBACK, $wgSettings );
    // Make any additional settings available in globals for use below
    $wgSettings->apply();
}
 
// Config can no longer be changed.
$wgSettings->enterReadOnlyStage();
 
// Set an appropriate locale (T291234)
// setlocale() will return the locale name actually set.
// The putenv() is meant to propagate the choice of locale to shell commands
// so that they will interpret UTF-8 correctly. If you have a problem with a
// shell command and need to send a special locale, you can override the locale
// with Command::environment().
putenv( "LC_ALL=" . setlocale( LC_ALL, 'C.UTF-8', 'C' ) );
 
// Set PHP runtime to the desired timezone
date_default_timezone_set( $wgLocaltimezone );
 
MWDebug::setup();
 
// Enable the global service locator.
// Trivial expansion of site configuration should go before this point.
// Any non-trivial expansion that requires calling into MediaWikiServices or other parts of MW.
MediaWikiServices::allowGlobalInstance();
 
// Define a constant that indicates that the bootstrapping of the service locator
// is complete.
define( 'MW_SERVICE_BOOTSTRAP_COMPLETE', 1 );
 
MWExceptionRenderer::setShowExceptionDetails( $wgShowExceptionDetails );
if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
    // Never install the handler in PHPUnit tests, otherwise PHPUnit's own handler will be unset and things
    // like convertWarningsToExceptions won't work.
    MWExceptionHandler::installHandler( $wgLogExceptionBacktrace, $wgPropagateErrors );
}
Profiler::init( $wgProfiler );
 
// Initialize the root span for distributed tracing if we're in a web request context (T340552).
// Do this here since subsequent setup code, e.g. session initialization or post-setup hooks,
// may themselves create spans, so the root span needs to have been initialized by then.
call_user_func( static function (): void {
    if ( wfIsCLI() ) {
        return;
    }
 
    $tracer = MediaWikiServices::getInstance()->getTracer();
    $request = RequestContext::getMain()->getRequest();
    // Backdate the start of the root span to the timestamp where PHP actually started working on this operation.
    $startTimeNanos = (int)( 1e9 * $_SERVER['REQUEST_TIME_FLOAT'] );
    // Avoid high cardinality URL path as root span name, instead safely use the HTTP method.
    // Per OTEL Semantic Conventions, https://opentelemetry.io/docs/specs/semconv/http/http-spans/
    $spanName = "EntryPoint " . MW_ENTRY_POINT . ".php HTTP {$request->getMethod()}";
    global $wgAllowExternalReqID;
    $rootSpan = $tracer->createRootSpanFromCarrier( $spanName, $wgAllowExternalReqID ? $request->getAllHeaders() : [] );
    $rootSpan->setSpanKind( SpanInterface::SPAN_KIND_SERVER )
            ->setAttributes( array_filter( [
                'http.request.method' => $request->getMethod(),
                'url.path' => $request->getRequestURL(),
                'server.name' => $_SERVER['SERVER_NAME'] ?? null,
            ] ) )
            ->start( $startTimeNanos );
    $rootSpan->activate();
 
    TracerState::getInstance()->setRootSpan( $rootSpan );
} );
 
// Non-trivial validation of: $wgServer
// The FatalError page only renders cleanly after MWExceptionHandler is installed.
if ( $wgServer === false ) {
    // T30798: $wgServer must be explicitly set
    throw new FatalError(
        '$wgServer must be set in LocalSettings.php. ' .
        'See <a href="https://www.mediawiki.org/wiki/Manual:$wgServer">' .
        'https://www.mediawiki.org/wiki/Manual:$wgServer</a>.'
    );
}
 
// Non-trivial expansion of: $wgCanonicalServer, $wgServerName.
// These require calling global functions.
// Also here are other settings that further depend on these two.
if ( $wgCanonicalServer === false ) {
    $wgCanonicalServer = MediaWikiServices::getInstance()->getUrlUtils()->getCanonicalServer();
}
$wgVirtualRestConfig['global']['domain'] = $wgCanonicalServer;
 
if ( $wgServerName !== false ) {
    wfWarn( '$wgServerName should be derived from $wgCanonicalServer, '
        . 'not customized. Overwriting $wgServerName.' );
}
$wgServerName = parse_url( $wgCanonicalServer, PHP_URL_HOST );
 
// $wgEmergencyContact and $wgPasswordSender may be false or empty string (T104142)
if ( !$wgEmergencyContact ) {
    $wgEmergencyContact = 'wikiadmin@' . $wgServerName;
}
if ( !$wgPasswordSender ) {
    $wgPasswordSender = 'apache@' . $wgServerName;
}
if ( !$wgNoReplyAddress ) {
    $wgNoReplyAddress = $wgPasswordSender;
}
 
// Non-trivial expansion of: $wgSecureLogin
// (due to calling wfWarn).
if ( $wgSecureLogin && !str_starts_with( $wgServer, '//' ) ) {
    $wgSecureLogin = false;
    wfWarn( 'Secure login was enabled on a server that only supports '
        . 'HTTP or HTTPS. Disabling secure login.' );
}
 
// Now that GlobalFunctions is loaded, set defaults that depend on it.
if ( $wgTmpDirectory === false ) {
    $wgTmpDirectory = wfTempDir();
}
 
if ( $wgSharedDB && $wgSharedTables ) {
    // Apply $wgSharedDB table aliases for the local LB (all non-foreign DB connections)
    MediaWikiServices::getInstance()->getDBLoadBalancer()->setTableAliases(
        array_fill_keys(
            $wgSharedTables,
            [
                'dbname' => $wgSharedDB,
                'schema' => $wgSharedSchema,
                'prefix' => $wgSharedPrefix
            ]
        )
    );
}
 
// Raise the memory limit if it's too low
// NOTE: This use wfDebug, and must remain after the MWDebug::setup() call.
wfMemoryLimit( $wgMemoryLimit );
 
// Explicit globals, so this works with bootstrap.php
global $wgRequest, $wgInitialSessionId;
 
// Initialize the request object in $wgRequest
$wgRequest = RequestContext::getMain()->getRequest(); // BackCompat
 
// Make sure that object caching does not undermine the ChronologyProtector improvements
if ( $wgRequest->getCookie( 'UseDC', '' ) === 'master' ) {
    // The user is pinned to the primary DC, meaning that they made recent changes which should
    // be reflected in their subsequent web requests. Avoid the use of interim cache keys because
    // they use a blind TTL and could be stale if an object changes twice in a short time span.
    MediaWikiServices::getInstance()->getMainWANObjectCache()->useInterimHoldOffCaching( false );
}
 
// Useful debug output
( static function () {
    global $wgRequest;
 
    $logger = LoggerFactory::getInstance( 'wfDebug' );
    if ( MW_ENTRY_POINT === 'cli' ) {
        $self = $_SERVER['PHP_SELF'] ?? '';
        $logger->debug( "\n\nStart command line script $self" );
    } else {
        $debug = "\n\nStart request {$wgRequest->getMethod()} {$wgRequest->getRequestURL()}\n";
        $debug .= "IP: " . $wgRequest->getIP() . "\n";
        $debug .= "HTTP HEADERS:\n";
        foreach ( $wgRequest->getAllHeaders() as $name => $value ) {
            $debug .= "$name: $value\n";
        }
        $debug .= "(end headers)";
        $logger->debug( $debug );
    }
} )();
 
// Most of the config is out, some might want to run hooks here.
( new HookRunner( MediaWikiServices::getInstance()->getHookContainer() ) )->onSetupAfterCache();
 
// Now that variant lists may be available, parse any action paths and article paths
// as query parameters.
//
// Skip title interpolation on API queries where it is useless and sometimes harmful (T18019).
//
// Optimization: Skip on load.php and all other entrypoints besides index.php to save time.
//
// TODO: Figure out if this can be safely done after everything else in Setup.php (e.g. any
// hooks or other state that would miss this?). If so, move to wfIndexMain or MediaWiki::run.
if ( MW_ENTRY_POINT === 'index' ) {
    $wgRequest->interpolateTitle();
}
 
$wgInitialSessionId = null;
if ( !defined( 'MW_NO_SESSION' ) && MW_ENTRY_POINT !== 'cli' ) {
    // If session.auto_start is there, we can't touch session name
    if ( $wgPHPSessionHandling !== 'disable' && !wfIniGetBool( 'session.auto_start' ) ) {
        HeaderCallback::warnIfHeadersSent();
        session_name( $wgSessionName ?: $wgCookiePrefix . '_session' );
    }
 
    // Create the SessionManager singleton and set up our session handler,
    // unless we're specifically asked not to.
    if ( !defined( 'MW_NO_SESSION_HANDLER' ) ) {
        MediaWiki\Session\PHPSessionHandler::install(
            MediaWiki\Session\SessionManager::singleton()
        );
    }
 
    $contLang = MediaWikiServices::getInstance()->getContentLanguage();
 
    // Initialize the session
    try {
        $session = MediaWiki\Session\SessionManager::getGlobalSession();
    } catch ( MediaWiki\Session\SessionOverflowException $ex ) {
        // The exception is because the request had multiple possible
        // sessions tied for top priority. Report this to the user.
        $list = [];
        foreach ( $ex->getSessionInfos() as $info ) {
            $list[] = $info->getProvider()->describe( $contLang );
        }
        $list = $contLang->listToText( $list );
        throw new HttpError( 400,
            Message::newFromKey( 'sessionmanager-tie', $list )->inLanguage( $contLang )
        );
    }
 
    unset( $contLang );
 
    if ( $session->isPersistent() ) {
        $wgInitialSessionId = $session->getSessionId();
    }
 
    $session->renew();
    if ( MediaWiki\Session\PHPSessionHandler::isEnabled() &&
        ( $session->isPersistent() || $session->shouldRememberUser() ) &&
        session_id() !== $session->getId()
    ) {
        // Start the PHP-session for backwards compatibility
        if ( session_id() !== '' ) {
            wfDebugLog( 'session', 'PHP session {old_id} was already started, changing to {new_id}', 'all', [
                'old_id' => session_id(),
                'new_id' => $session->getId(),
            ] );
            session_write_close();
        }
        session_id( $session->getId() );
        session_start();
    }
 
    unset( $session );
} else {
    // Even if we didn't set up a global Session, still install our session
    // handler unless specifically requested not to.
    if ( !defined( 'MW_NO_SESSION_HANDLER' ) ) {
        MediaWiki\Session\PHPSessionHandler::install(
            MediaWiki\Session\SessionManager::singleton()
        );
    }
}
 
// Explicit globals, so this works with bootstrap.php
global $wgUser, $wgLang, $wgOut, $wgTitle;
 
$wgUser = new StubGlobalUser( RequestContext::getMain()->getUser() ); // BackCompat
register_shutdown_function( static function () {
    StubGlobalUser::$destructorDeprecationDisarmed = true;
} );
 
$wgLang = new StubUserLang;
 
$wgOut = RequestContext::getMain()->getOutput(); // BackCompat
 
$wgTitle = null;
 
// Explicit globals, so this works with bootstrap.php
global $wgFullyInitialised, $wgExtensionFunctions;
 
// Extension setup functions
// Entries should be added to this variable during the inclusion
// of the extension file. This allows the extension to perform
// any necessary initialisation in the fully initialised environment
foreach ( $wgExtensionFunctions as $func ) {
    $func();
}
unset( $func ); // no global pollution; destroy reference
 
// If the session user has a 0 id but a valid name, that means we need to
// autocreate it.
if ( !defined( 'MW_NO_SESSION' ) && MW_ENTRY_POINT !== 'cli' ) {
    $sessionUser = MediaWiki\Session\SessionManager::getGlobalSession()->getUser();
    if ( $sessionUser->getId() === 0 &&
        MediaWikiServices::getInstance()->getUserNameUtils()->isValid( $sessionUser->getName() )
    ) {
        MediaWikiServices::getInstance()->getAuthManager()->autoCreateUser(
            $sessionUser,
            MediaWiki\Auth\AuthManager::AUTOCREATE_SOURCE_SESSION,
            true,
            true,
            $sessionUser
        );
    }
    unset( $sessionUser );
}
 
// Optimization: Avoid overhead from DeferredUpdates and Pingback deps when turned off.
if ( MW_ENTRY_POINT !== 'cli' && $wgPingback ) {
    // NOTE: Do not refactor to inject Config or otherwise make unconditional service call.
    //
    // On a plain install of MediaWiki, Pingback is likely the *only* feature
    // involving DeferredUpdates or DB_PRIMARY on a regular page view.
    // To allow for error recovery and fault isolation, let admins turn this
    // off completely. (T269516)
    DeferredUpdates::addCallableUpdate( static function () {
        MediaWikiServices::getInstance()->getPingback()->run();
    } );
}
 
$settingsWarnings = $wgSettings->getWarnings();
if ( $settingsWarnings ) {
    $logger = LoggerFactory::getInstance( 'Settings' );
    foreach ( $settingsWarnings as $msg ) {
        $logger->warning( $msg );
    }
    unset( $logger );
}
 
unset( $settingsWarnings );
 
// Explicit globals, so this works with bootstrap.php
global $wgFullyInitialised;
$wgFullyInitialised = true;
 
// T264370
if ( !defined( 'MW_NO_SESSION' ) && MW_ENTRY_POINT !== 'cli' ) {
    MediaWiki\Session\SessionManager::singleton()->logPotentialSessionLeakage();
}