ServiceWiring.php

Go to the documentation of this file.

<?php
use MediaWiki\Interwiki\ClassicInterwikiLookup;
use MediaWiki\Linker\LinkRendererFactory;
use MediaWiki\MediaWikiServices;

return [
    'DBLoadBalancerFactory' => function( MediaWikiServices $services ) {
        $config = $services->getMainConfig()->get( 'LBFactoryConf' );

        $class = LBFactory::getLBFactoryClass( $config );
        if ( !isset( $config['readOnlyReason'] ) ) {
            // TODO: replace the global wfConfiguredReadOnlyReason() with a service.
            $config['readOnlyReason'] = wfConfiguredReadOnlyReason();
        }

        return new $class( $config );
    },

    'DBLoadBalancer' => function( MediaWikiServices $services ) {
        // just return the default LB from the DBLoadBalancerFactory service
        return $services->getDBLoadBalancerFactory()->getMainLB();
    },

    'SiteStore' => function( MediaWikiServices $services ) {
        $rawSiteStore = new DBSiteStore( $services->getDBLoadBalancer() );

        // TODO: replace wfGetCache with a CacheFactory service.
        // TODO: replace wfIsHHVM with a capabilities service.
        $cache = wfGetCache( wfIsHHVM() ? CACHE_ACCEL : CACHE_ANYTHING );

        return new CachingSiteStore( $rawSiteStore, $cache );
    },

    'SiteLookup' => function( MediaWikiServices $services ) {
        // Use the default SiteStore as the SiteLookup implementation for now
        return $services->getSiteStore();
    },

    'ConfigFactory' => function( MediaWikiServices $services ) {
        // Use the bootstrap config to initialize the ConfigFactory.
        $registry = $services->getBootstrapConfig()->get( 'ConfigRegistry' );
        $factory = new ConfigFactory();

        foreach ( $registry as $name => $callback ) {
            $factory->register( $name, $callback );
        }
        return $factory;
    },

    'MainConfig' => function( MediaWikiServices $services ) {
        // Use the 'main' config from the ConfigFactory service.
        return $services->getConfigFactory()->makeConfig( 'main' );
    },

    'InterwikiLookup' => function( MediaWikiServices $services ) {
        global $wgContLang; // TODO: manage $wgContLang as a service
        $config = $services->getMainConfig();
        return new ClassicInterwikiLookup(
            $wgContLang,
            ObjectCache::getMainWANInstance(),
            $config->get( 'InterwikiExpiry' ),
            $config->get( 'InterwikiCache' ),
            $config->get( 'InterwikiScopes' ),
            $config->get( 'InterwikiFallbackSite' )
        );
    },

    'StatsdDataFactory' => function( MediaWikiServices $services ) {
        return new BufferingStatsdDataFactory(
            rtrim( $services->getMainConfig()->get( 'StatsdMetricPrefix' ), '.' )
        );
    },

    'EventRelayerGroup' => function( MediaWikiServices $services ) {
        return new EventRelayerGroup( $services->getMainConfig()->get( 'EventRelayerConfig' ) );
    },

    'SearchEngineFactory' => function( MediaWikiServices $services ) {
        return new SearchEngineFactory( $services->getSearchEngineConfig() );
    },

    'SearchEngineConfig' => function( MediaWikiServices $services ) {
        global $wgContLang;
        return new SearchEngineConfig( $services->getMainConfig(), $wgContLang );
    },

    'SkinFactory' => function( MediaWikiServices $services ) {
        $factory = new SkinFactory();

        $names = $services->getMainConfig()->get( 'ValidSkinNames' );

        foreach ( $names as $name => $skin ) {
            $factory->register( $name, $skin, function () use ( $name, $skin ) {
                $class = "Skin$skin";
                return new $class( $name );
            } );
        }
        // Register a hidden "fallback" skin
        $factory->register( 'fallback', 'Fallback', function () {
            return new SkinFallback;
        } );
        // Register a hidden skin for api output
        $factory->register( 'apioutput', 'ApiOutput', function () {
            return new SkinApi;
        } );

        return $factory;
    },

    'WatchedItemStore' => function( MediaWikiServices $services ) {
        $store = new WatchedItemStore(
            $services->getDBLoadBalancer(),
            new HashBagOStuff( [ 'maxKeys' => 100 ] )
        );
        $store->setStatsdDataFactory( $services->getStatsdDataFactory() );
        return $store;
    },

    'WatchedItemQueryService' => function( MediaWikiServices $services ) {
        return new WatchedItemQueryService( $services->getDBLoadBalancer() );
    },

    'LinkCache' => function( MediaWikiServices $services ) {
        return new LinkCache(
            $services->getTitleFormatter()
        );
    },

    'LinkRendererFactory' => function( MediaWikiServices $services ) {
        return new LinkRendererFactory(
            $services->getTitleFormatter(),
            $services->getLinkCache()
        );
    },

    'LinkRenderer' => function( MediaWikiServices $services ) {
        global $wgUser;

        if ( defined( 'MW_NO_SESSION' ) ) {
            return $services->getLinkRendererFactory()->create();
        } else {
            return $services->getLinkRendererFactory()->createForUser( $wgUser );
        }
    },

    'GenderCache' => function( MediaWikiServices $services ) {
        return new GenderCache();
    },

    '_MediaWikiTitleCodec' => function( MediaWikiServices $services ) {
        global $wgContLang;

        return new MediaWikiTitleCodec(
            $wgContLang,
            $services->getGenderCache(),
            $services->getMainConfig()->get( 'LocalInterwikis' )
        );
    },

    'TitleFormatter' => function( MediaWikiServices $services ) {
        return $services->getService( '_MediaWikiTitleCodec' );
    },

    'TitleParser' => function( MediaWikiServices $services ) {
        return $services->getService( '_MediaWikiTitleCodec' );
    },

    // NOTE: When adding a service here, don't forget to add a getter function
    // in the MediaWikiServices class. The convenience getter should just call
    // $this->getService( 'FooBarService' ).

];