MediaWikiServices.php

Go to the documentation of this file.

<?php
namespace MediaWiki;

use ActorMigration;
use CommentStore;
use Config;
use ConfigFactory;
use CryptHKDF;
use DateFormatterFactory;
use EventRelayerGroup;
use GenderCache;
use GlobalVarConfig;
use Hooks;
use IBufferingStatsdDataFactory;
use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
use MediaWiki\Http\HttpRequestFactory;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\Preferences\PreferencesFactory;
use MediaWiki\Shell\CommandFactory;
use MediaWiki\Revision\RevisionRenderer;
use MediaWiki\Revision\SlotRoleRegistry;
use MediaWiki\Special\SpecialPageFactory;
use MediaWiki\Storage\BlobStore;
use MediaWiki\Storage\BlobStoreFactory;
use MediaWiki\Storage\NameTableStore;
use MediaWiki\Storage\NameTableStoreFactory;
use MediaWiki\Revision\RevisionFactory;
use MediaWiki\Revision\RevisionLookup;
use MediaWiki\Revision\RevisionStore;
use OldRevisionImporter;
use MediaWiki\Revision\RevisionStoreFactory;
use UploadRevisionImporter;
use Wikimedia\Rdbms\LBFactory;
use LinkCache;
use Wikimedia\Rdbms\LoadBalancer;
use MediaHandlerFactory;
use MediaWiki\Config\ConfigRepository;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Linker\LinkRendererFactory;
use MWException;
use MimeAnalyzer;
use NamespaceInfo;
use ObjectCache;
use Parser;
use ParserCache;
use ParserFactory;
use PasswordFactory;
use ProxyLookup;
use ResourceLoader;
use SearchEngine;
use SearchEngineConfig;
use SearchEngineFactory;
use SiteLookup;
use SiteStore;
use WatchedItemStoreInterface;
use WatchedItemQueryService;
use SkinFactory;
use TitleFormatter;
use TitleParser;
use VirtualRESTServiceClient;
use Wikimedia\Services\SalvageableService;
use Wikimedia\Services\ServiceContainer;
use Wikimedia\Services\NoSuchServiceException;
use MediaWiki\Interwiki\InterwikiLookup;
use MagicWordFactory;

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 getActorMigration() {
        return $this->getService( 'ActorMigration' );
    }

    public function getBlobStore() {
        return $this->getService( '_SqlBlobStore' );
    }

    public function getBlobStoreFactory() {
        return $this->getService( 'BlobStoreFactory' );
    }

    public function getBootstrapConfig() {
        return $this->getService( 'BootstrapConfig' );
    }

    public function getChangeTagDefStore() {
        return $this->getService( 'NameTableStoreFactory' )->getChangeTagDef();
    }

    public function getCommentStore() {
        return $this->getService( 'CommentStore' );
    }

    public function getConfigFactory() {
        return $this->getService( 'ConfigFactory' );
    }

    public function getConfigRepository() {
        return $this->getService( 'ConfigRepository' );
    }

    public function getConfiguredReadOnlyMode() {
        return $this->getService( 'ConfiguredReadOnlyMode' );
    }

    public function getContentLanguage() {
        return $this->getService( 'ContentLanguage' );
    }

    public function getContentModelStore() {
        return $this->getService( 'NameTableStoreFactory' )->getContentModels();
    }

    public function getCryptHKDF() {
        return $this->getService( 'CryptHKDF' );
    }

    public function getDateFormatterFactory() {
        return $this->getService( 'DateFormatterFactory' );
    }

    public function getDBLoadBalancer() {
        return $this->getService( 'DBLoadBalancer' );
    }

    public function getDBLoadBalancerFactory() {
        return $this->getService( 'DBLoadBalancerFactory' );
    }

    public function getEventRelayerGroup() {
        return $this->getService( 'EventRelayerGroup' );
    }

    public function getExternalStoreFactory() {
        return $this->getService( 'ExternalStoreFactory' );
    }

    public function getGenderCache() {
        return $this->getService( 'GenderCache' );
    }

    public function getHttpRequestFactory() {
        return $this->getService( 'HttpRequestFactory' );
    }

    public function getInterwikiLookup() {
        return $this->getService( 'InterwikiLookup' );
    }

    public function getLinkCache() {
        return $this->getService( 'LinkCache' );
    }

    public function getLinkRenderer() {
        return $this->getService( 'LinkRenderer' );
    }

    public function getLinkRendererFactory() {
        return $this->getService( 'LinkRendererFactory' );
    }

    public function getLocalServerObjectCache() {
        return $this->getService( 'LocalServerObjectCache' );
    }

    public function getMagicWordFactory() {
        return $this->getService( 'MagicWordFactory' );
    }

    public function getMainConfig() {
        return $this->getService( 'MainConfig' );
    }

    public function getMainObjectStash() {
        return $this->getService( 'MainObjectStash' );
    }

    public function getMainWANObjectCache() {
        return $this->getService( 'MainWANObjectCache' );
    }

    public function getMediaHandlerFactory() {
        return $this->getService( 'MediaHandlerFactory' );
    }

    public function getMimeAnalyzer() {
        return $this->getService( 'MimeAnalyzer' );
    }

    public function getNamespaceInfo() : NamespaceInfo {
        return $this->getService( 'NamespaceInfo' );
    }

    public function getNameTableStoreFactory() {
        return $this->getService( 'NameTableStoreFactory' );
    }

    public function getOldRevisionImporter() {
        return $this->getService( 'OldRevisionImporter' );
    }

    public function getParser() {
        return $this->getService( 'Parser' );
    }

    public function getParserCache() {
        return $this->getService( 'ParserCache' );
    }

    public function getParserFactory() {
        return $this->getService( 'ParserFactory' );
    }

    public function getPasswordFactory() {
        return $this->getService( 'PasswordFactory' );
    }

    public function getPerDbNameStatsdDataFactory() {
        return $this->getService( 'PerDbNameStatsdDataFactory' );
    }

    public function getPermissionManager() {
        return $this->getService( 'PermissionManager' );
    }

    public function getPreferencesFactory() {
        return $this->getService( 'PreferencesFactory' );
    }

    public function getProxyLookup() {
        return $this->getService( 'ProxyLookup' );
    }

    public function getReadOnlyMode() {
        return $this->getService( 'ReadOnlyMode' );
    }

    public function getResourceLoader() {
        return $this->getService( 'ResourceLoader' );
    }

    public function getRevisionFactory() {
        return $this->getService( 'RevisionFactory' );
    }

    public function getRevisionLookup() {
        return $this->getService( 'RevisionLookup' );
    }

    public function getRevisionRenderer() {
        return $this->getService( 'RevisionRenderer' );
    }

    public function getRevisionStore() {
        return $this->getService( 'RevisionStore' );
    }

    public function getRevisionStoreFactory() {
        return $this->getService( 'RevisionStoreFactory' );
    }

    public function newSearchEngine() {
        // New engine object every time, since they keep state
        return $this->getService( 'SearchEngineFactory' )->create();
    }

    public function getSearchEngineConfig() {
        return $this->getService( 'SearchEngineConfig' );
    }

    public function getSearchEngineFactory() {
        return $this->getService( 'SearchEngineFactory' );
    }

    public function getShellCommandFactory() {
        return $this->getService( 'ShellCommandFactory' );
    }

    public function getSiteLookup() {
        return $this->getService( 'SiteLookup' );
    }

    public function getSiteStore() {
        return $this->getService( 'SiteStore' );
    }

    public function getSkinFactory() {
        return $this->getService( 'SkinFactory' );
    }

    public function getSlotRoleRegistry() {
        return $this->getService( 'SlotRoleRegistry' );
    }

    public function getSlotRoleStore() {
        return $this->getService( 'NameTableStoreFactory' )->getSlotRoles();
    }

    public function getSpecialPageFactory() : SpecialPageFactory {
        return $this->getService( 'SpecialPageFactory' );
    }

    public function getStatsdDataFactory() {
        return $this->getService( 'StatsdDataFactory' );
    }

    public function getTitleFormatter() {
        return $this->getService( 'TitleFormatter' );
    }

    public function getTitleParser() {
        return $this->getService( 'TitleParser' );
    }

    public function getUploadRevisionImporter() {
        return $this->getService( 'UploadRevisionImporter' );
    }

    public function getVirtualRESTServiceClient() {
        return $this->getService( 'VirtualRESTServiceClient' );
    }

    public function getWatchedItemQueryService() {
        return $this->getService( 'WatchedItemQueryService' );
    }

    public function getWatchedItemStore() {
        return $this->getService( 'WatchedItemStore' );
    }

    public function getWikiRevisionOldRevisionImporter() {
        return $this->getService( 'OldRevisionImporter' );
    }

    public function getWikiRevisionOldRevisionImporterNoUpdates() {
        return $this->getService( 'WikiRevisionOldRevisionImporterNoUpdates' );
    }

    public function getWikiRevisionUploadImporter() {
        return $this->getService( 'UploadRevisionImporter' );
    }

}