MediaWikiServices.php

Go to the documentation of this file.

<?php
namespace MediaWiki;
 
use Config;
use ConfigFactory;
use CryptHKDF;
use CryptRand;
use EventRelayerGroup;
use GenderCache;
use GlobalVarConfig;
use Hooks;
use IBufferingStatsdDataFactory;
use MediaWiki\Shell\CommandFactory;
use Wikimedia\Rdbms\LBFactory;
use LinkCache;
use Wikimedia\Rdbms\LoadBalancer;
use MediaHandlerFactory;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Linker\LinkRendererFactory;
use MediaWiki\Services\SalvageableService;
use MediaWiki\Services\ServiceContainer;
use MediaWiki\Services\NoSuchServiceException;
use MWException;
use MimeAnalyzer;
use ObjectCache;
use Parser;
use ParserCache;
use ProxyLookup;
use SearchEngine;
use SearchEngineConfig;
use SearchEngineFactory;
use SiteLookup;
use SiteStore;
use WatchedItemStore;
use WatchedItemQueryService;
use SkinFactory;
use TitleFormatter;
use TitleParser;
use VirtualRESTServiceClient;
use MediaWiki\Interwiki\InterwikiLookup;
 
class MediaWikiServices extends ServiceContainer {
 
    private static $instance = null;
 
    public static function getInstance() {
        if ( self::$instance === null ) {
            // NOTE: constructing GlobalVarConfig here is not particularly pretty,
            // but some information from the global scope has to be injected here,
            // even if it's just a file name or database credentials to load
            // configuration from.
            $bootstrapConfig = new GlobalVarConfig();
            self::$instance = self::newInstance( $bootstrapConfig, 'load' );
        }
 
        return self::$instance;
    }
 
    public static function forceGlobalInstance( MediaWikiServices $services ) {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new MWException( __METHOD__ . ' must not be used outside unit tests.' );
        }
 
        $old = self::getInstance();
        self::$instance = $services;
 
        return $old;
    }
 
    public static function resetGlobalInstance( Config $bootstrapConfig = null, $quick = '' ) {
        if ( self::$instance === null ) {
            // no global instance yet, nothing to reset
            return;
        }
 
        self::failIfResetNotAllowed( __METHOD__ );
 
        if ( $bootstrapConfig === null ) {
            $bootstrapConfig = self::$instance->getBootstrapConfig();
        }
 
        $oldInstance = self::$instance;
 
        self::$instance = self::newInstance( $bootstrapConfig, 'load' );
        self::$instance->importWiring( $oldInstance, [ 'BootstrapConfig' ] );
 
        if ( $quick === 'quick' ) {
            self::$instance->salvage( $oldInstance );
        } else {
            $oldInstance->destroy();
        }
    }
 
    private function salvage( self $other ) {
        foreach ( $this->getServiceNames() as $name ) {
            // The service could be new in the new instance and not registered in the
            // other instance (e.g. an extension that was loaded after the instantiation of
            // the other instance. Skip this service in this case. See T143974
            try {
                $oldService = $other->peekService( $name );
            } catch ( NoSuchServiceException $e ) {
                continue;
            }
 
            if ( $oldService instanceof SalvageableService ) {
                $newService = $this->getService( $name );
                $newService->salvage( $oldService );
            }
        }
 
        $other->destroy();
    }
 
    private static function newInstance( Config $bootstrapConfig, $loadWiring = '' ) {
        $instance = new self( $bootstrapConfig );
 
        // Load the default wiring from the specified files.
        if ( $loadWiring === 'load' ) {
            $wiringFiles = $bootstrapConfig->get( 'ServiceWiringFiles' );
            $instance->loadWiringFiles( $wiringFiles );
        }
 
        // Provide a traditional hook point to allow extensions to configure services.
        Hooks::run( 'MediaWikiServices', [ $instance ] );
 
        return $instance;
    }
 
    public static function disableStorageBackend() {
        // TODO: also disable some Caches, JobQueues, etc
        $destroy = [ 'DBLoadBalancer', 'DBLoadBalancerFactory' ];
        $services = self::getInstance();
 
        foreach ( $destroy as $name ) {
            $services->disableService( $name );
        }
 
        ObjectCache::clear();
    }
 
    public static function resetChildProcessServices() {
        // NOTE: for now, just reset everything. Since we don't know the interdependencies
        // between services, we can't do this more selectively at this time.
        self::resetGlobalInstance();
 
        // Child, reseed because there is no bug in PHP:
        // https://bugs.php.net/bug.php?id=42465
        mt_srand( getmypid() );
    }
 
    public function resetServiceForTesting( $name, $destroy = true ) {
        if ( !defined( 'MW_PHPUNIT_TEST' ) && !defined( 'MW_PARSER_TEST' ) ) {
            throw new MWException( 'resetServiceForTesting() must not be used outside unit tests.' );
        }
 
        $this->resetService( $name, $destroy );
    }
 
    public static function failIfResetNotAllowed( $method ) {
        if ( !defined( 'MW_PHPUNIT_TEST' )
            && !defined( 'MW_PARSER_TEST' )
            && !defined( 'MEDIAWIKI_INSTALL' )
            && !defined( 'RUN_MAINTENANCE_IF_MAIN' )
            && defined( 'MW_SERVICE_BOOTSTRAP_COMPLETE' )
        ) {
            throw new MWException( $method . ' may only be called during bootstrapping and unit tests!' );
        }
    }
 
    public function __construct( Config $config ) {
        parent::__construct();
 
        // Register the given Config object as the bootstrap config service.
        $this->defineService( 'BootstrapConfig', function () use ( $config ) {
            return $config;
        } );
    }
 
    // CONVENIENCE GETTERS ////////////////////////////////////////////////////
 
    public function getBootstrapConfig() {
        return $this->getService( 'BootstrapConfig' );
    }
 
    public function getConfigFactory() {
        return $this->getService( 'ConfigFactory' );
    }
 
    public function getMainConfig() {
        return $this->getService( 'MainConfig' );
    }
 
    public function getSiteLookup() {
        return $this->getService( 'SiteLookup' );
    }
 
    public function getSiteStore() {
        return $this->getService( 'SiteStore' );
    }
 
    public function getInterwikiLookup() {
        return $this->getService( 'InterwikiLookup' );
    }
 
    public function getStatsdDataFactory() {
        return $this->getService( 'StatsdDataFactory' );
    }
 
    public function getEventRelayerGroup() {
        return $this->getService( 'EventRelayerGroup' );
    }
 
    public function newSearchEngine() {
        // New engine object every time, since they keep state
        return $this->getService( 'SearchEngineFactory' )->create();
    }
 
    public function getSearchEngineFactory() {
        return $this->getService( 'SearchEngineFactory' );
    }
 
    public function getSearchEngineConfig() {
        return $this->getService( 'SearchEngineConfig' );
    }
 
    public function getSkinFactory() {
        return $this->getService( 'SkinFactory' );
    }
 
    public function getDBLoadBalancerFactory() {
        return $this->getService( 'DBLoadBalancerFactory' );
    }
 
    public function getDBLoadBalancer() {
        return $this->getService( 'DBLoadBalancer' );
    }
 
    public function getWatchedItemStore() {
        return $this->getService( 'WatchedItemStore' );
    }
 
    public function getWatchedItemQueryService() {
        return $this->getService( 'WatchedItemQueryService' );
    }
 
    public function getCryptRand() {
        return $this->getService( 'CryptRand' );
    }
 
    public function getCryptHKDF() {
        return $this->getService( 'CryptHKDF' );
    }
 
    public function getMediaHandlerFactory() {
        return $this->getService( 'MediaHandlerFactory' );
    }
 
    public function getMimeAnalyzer() {
        return $this->getService( 'MimeAnalyzer' );
    }
 
    public function getProxyLookup() {
        return $this->getService( 'ProxyLookup' );
    }
 
    public function getParser() {
        return $this->getService( 'Parser' );
    }
 
    public function getParserCache() {
        return $this->getService( 'ParserCache' );
    }
 
    public function getGenderCache() {
        return $this->getService( 'GenderCache' );
    }
 
    public function getLinkCache() {
        return $this->getService( 'LinkCache' );
    }
 
    public function getLinkRendererFactory() {
        return $this->getService( 'LinkRendererFactory' );
    }
 
    public function getLinkRenderer() {
        return $this->getService( 'LinkRenderer' );
    }
 
    public function getTitleFormatter() {
        return $this->getService( 'TitleFormatter' );
    }
 
    public function getTitleParser() {
        return $this->getService( 'TitleParser' );
    }
 
    public function getMainObjectStash() {
        return $this->getService( 'MainObjectStash' );
    }
 
    public function getMainWANObjectCache() {
        return $this->getService( 'MainWANObjectCache' );
    }
 
    public function getLocalServerObjectCache() {
        return $this->getService( 'LocalServerObjectCache' );
    }
 
    public function getVirtualRESTServiceClient() {
        return $this->getService( 'VirtualRESTServiceClient' );
    }
 
    public function getConfiguredReadOnlyMode() {
        return $this->getService( 'ConfiguredReadOnlyMode' );
    }
 
    public function getReadOnlyMode() {
        return $this->getService( 'ReadOnlyMode' );
    }
 
    public function getShellCommandFactory() {
        return $this->getService( 'ShellCommandFactory' );
    }
 
    // NOTE: When adding a service getter here, don't forget to add a test
    // case for it in MediaWikiServicesTest::provideGetters() and in
    // MediaWikiServicesTest::provideGetService()!
 
}