Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
0.00% covered (danger)
0.00%
0 / 2027
n/a
0 / 0
CRAP
n/a
0 / 0
1<?php
2/**
3 * Service implementations for %MediaWiki core.
4 *
5 * This file returns the array loaded by the MediaWikiServices class
6 * for use through `MediaWiki\MediaWikiServices::getInstance()`
7 *
8 * @see [Dependency Injection](@ref dependencyinjection) in docs/Injection.md
9 * for the principles of DI and how to use it MediaWiki core.
10 *
11 * Reminder:
12 *
13 * - ServiceWiring is NOT a cache for arbitrary singletons.
14 *
15 * - Services MUST NOT vary their behaviour on global state, especially not
16 *   WebRequest, RequestContext (T218555), or other details of the current
17 *   request or CLI process (e.g. "current" user or title). Doing so may
18 *   cause a chain reaction and cause serious data corruption.
19 *
20 *   Refer to [DI Principles](@ref di-principles) in docs/Injection.md for
21 *   how and why we avoid this, as well as for limited exemptions to these
22 *   principles.
23 *
24 * -------
25 *
26 * This program is free software; you can redistribute it and/or modify
27 * it under the terms of the GNU General Public License as published by
28 * the Free Software Foundation; either version 2 of the License, or
29 * (at your option) any later version.
30 *
31 * This program is distributed in the hope that it will be useful,
32 * but WITHOUT ANY WARRANTY; without even the implied warranty of
33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 * GNU General Public License for more details.
35 *
36 * You should have received a copy of the GNU General Public License along
37 * with this program; if not, write to the Free Software Foundation, Inc.,
38 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
39 * http://www.gnu.org/copyleft/gpl.html
40 *
41 * @file
42 */
43
44use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
45use MediaWiki\Actions\ActionFactory;
46use MediaWiki\Auth\AuthManager;
47use MediaWiki\Auth\Throttler;
48use MediaWiki\Block\AutoblockExemptionList;
49use MediaWiki\Block\BlockActionInfo;
50use MediaWiki\Block\BlockErrorFormatter;
51use MediaWiki\Block\BlockManager;
52use MediaWiki\Block\BlockPermissionCheckerFactory;
53use MediaWiki\Block\BlockRestrictionStore;
54use MediaWiki\Block\BlockRestrictionStoreFactory;
55use MediaWiki\Block\BlockUserFactory;
56use MediaWiki\Block\BlockUtils;
57use MediaWiki\Block\BlockUtilsFactory;
58use MediaWiki\Block\DatabaseBlock;
59use MediaWiki\Block\DatabaseBlockStore;
60use MediaWiki\Block\DatabaseBlockStoreFactory;
61use MediaWiki\Block\HideUserUtils;
62use MediaWiki\Block\UnblockUserFactory;
63use MediaWiki\Block\UserBlockCommandFactory;
64use MediaWiki\Cache\BacklinkCache;
65use MediaWiki\Cache\BacklinkCacheFactory;
66use MediaWiki\Cache\GenderCache;
67use MediaWiki\Cache\HTMLCacheUpdater;
68use MediaWiki\Cache\LinkBatchFactory;
69use MediaWiki\Cache\LinkCache;
70use MediaWiki\Cache\UserCache;
71use MediaWiki\Category\TrackingCategories;
72use MediaWiki\ChangeTags\ChangeTagsStore;
73use MediaWiki\Collation\CollationFactory;
74use MediaWiki\CommentFormatter\CommentFormatter;
75use MediaWiki\CommentFormatter\CommentParserFactory;
76use MediaWiki\CommentFormatter\RowCommentFormatter;
77use MediaWiki\CommentStore\CommentStore;
78use MediaWiki\Config\Config;
79use MediaWiki\Config\ConfigException;
80use MediaWiki\Config\ConfigFactory;
81use MediaWiki\Config\ConfigRepository;
82use MediaWiki\Config\ServiceOptions;
83use MediaWiki\Content\ContentHandlerFactory;
84use MediaWiki\Content\IContentHandlerFactory;
85use MediaWiki\Content\Renderer\ContentRenderer;
86use MediaWiki\Content\Transform\ContentTransformer;
87use MediaWiki\Context\RequestContext;
88use MediaWiki\DAO\WikiAwareEntity;
89use MediaWiki\Deferred\DeferredUpdates;
90use MediaWiki\Edit\ParsoidOutputStash;
91use MediaWiki\Edit\SimpleParsoidOutputStash;
92use MediaWiki\EditPage\Constraint\EditConstraintFactory;
93use MediaWiki\EditPage\IntroMessageBuilder;
94use MediaWiki\EditPage\PreloadedContentBuilder;
95use MediaWiki\EditPage\SpamChecker;
96use MediaWiki\Export\WikiExporterFactory;
97use MediaWiki\FileBackend\FSFile\TempFSFileFactory;
98use MediaWiki\FileBackend\LockManager\LockManagerGroupFactory;
99use MediaWiki\HookContainer\FauxGlobalHookArray;
100use MediaWiki\HookContainer\HookContainer;
101use MediaWiki\HookContainer\HookRunner;
102use MediaWiki\HookContainer\StaticHookRegistry;
103use MediaWiki\Http\HttpRequestFactory;
104use MediaWiki\Http\Telemetry;
105use MediaWiki\Installer\Pingback;
106use MediaWiki\Interwiki\ClassicInterwikiLookup;
107use MediaWiki\Interwiki\InterwikiLookup;
108use MediaWiki\JobQueue\JobFactory;
109use MediaWiki\JobQueue\JobQueueGroupFactory;
110use MediaWiki\Json\JsonCodec;
111use MediaWiki\Language\FormatterFactory;
112use MediaWiki\Language\LazyLocalizationContext;
113use MediaWiki\Languages\LanguageConverterFactory;
114use MediaWiki\Languages\LanguageFactory;
115use MediaWiki\Languages\LanguageFallback;
116use MediaWiki\Languages\LanguageNameUtils;
117use MediaWiki\Linker\LinkRenderer;
118use MediaWiki\Linker\LinkRendererFactory;
119use MediaWiki\Linker\LinksMigration;
120use MediaWiki\Linker\LinkTargetLookup;
121use MediaWiki\Linker\LinkTargetStore;
122use MediaWiki\Logger\LoggerFactory;
123use MediaWiki\Mail\Emailer;
124use MediaWiki\Mail\EmailUser;
125use MediaWiki\Mail\EmailUserFactory;
126use MediaWiki\Mail\IEmailer;
127use MediaWiki\MainConfigNames;
128use MediaWiki\MediaWikiServices;
129use MediaWiki\Message\MessageFormatterFactory;
130use MediaWiki\OutputTransform\DefaultOutputPipelineFactory;
131use MediaWiki\OutputTransform\OutputTransformPipeline;
132use MediaWiki\Page\ContentModelChangeFactory;
133use MediaWiki\Page\DeletePageFactory;
134use MediaWiki\Page\File\BadFileLookup;
135use MediaWiki\Page\MergeHistoryFactory;
136use MediaWiki\Page\MovePageFactory;
137use MediaWiki\Page\PageCommandFactory;
138use MediaWiki\Page\PageProps;
139use MediaWiki\Page\PageStore;
140use MediaWiki\Page\PageStoreFactory;
141use MediaWiki\Page\ParserOutputAccess;
142use MediaWiki\Page\RedirectLookup;
143use MediaWiki\Page\RedirectStore;
144use MediaWiki\Page\RollbackPageFactory;
145use MediaWiki\Page\UndeletePageFactory;
146use MediaWiki\Page\WikiPageFactory;
147use MediaWiki\Parser\MagicWordFactory;
148use MediaWiki\Parser\Parser;
149use MediaWiki\Parser\ParserCacheFactory;
150use MediaWiki\Parser\ParserObserver;
151use MediaWiki\Parser\Parsoid\Config\DataAccess as MWDataAccess;
152use MediaWiki\Parser\Parsoid\Config\PageConfigFactory as MWPageConfigFactory;
153use MediaWiki\Parser\Parsoid\Config\SiteConfig as MWSiteConfig;
154use MediaWiki\Parser\Parsoid\HtmlTransformFactory;
155use MediaWiki\Parser\Parsoid\ParsoidOutputAccess;
156use MediaWiki\Parser\Parsoid\ParsoidParserFactory;
157use MediaWiki\Permissions\GrantsInfo;
158use MediaWiki\Permissions\GrantsLocalization;
159use MediaWiki\Permissions\GroupPermissionsLookup;
160use MediaWiki\Permissions\PermissionManager;
161use MediaWiki\Permissions\RateLimiter;
162use MediaWiki\Permissions\RestrictionStore;
163use MediaWiki\PoolCounter\PoolCounterFactory;
164use MediaWiki\Preferences\DefaultPreferencesFactory;
165use MediaWiki\Preferences\PreferencesFactory;
166use MediaWiki\Preferences\SignatureValidator;
167use MediaWiki\Preferences\SignatureValidatorFactory;
168use MediaWiki\Request\ProxyLookup;
169use MediaWiki\Request\WebRequest;
170use MediaWiki\ResourceLoader\MessageBlobStore;
171use MediaWiki\ResourceLoader\ResourceLoader;
172use MediaWiki\Rest\Handler\Helper\PageRestHelperFactory;
173use MediaWiki\Revision\ArchivedRevisionLookup;
174use MediaWiki\Revision\ContributionsLookup;
175use MediaWiki\Revision\MainSlotRoleHandler;
176use MediaWiki\Revision\RevisionFactory;
177use MediaWiki\Revision\RevisionLookup;
178use MediaWiki\Revision\RevisionRenderer;
179use MediaWiki\Revision\RevisionStore;
180use MediaWiki\Revision\RevisionStoreFactory;
181use MediaWiki\Revision\SlotRecord;
182use MediaWiki\Revision\SlotRoleRegistry;
183use MediaWiki\Search\SearchResultThumbnailProvider;
184use MediaWiki\Search\TitleMatcher;
185use MediaWiki\Settings\Config\ConfigSchema;
186use MediaWiki\Settings\SettingsBuilder;
187use MediaWiki\Shell\CommandFactory;
188use MediaWiki\Shell\ShellboxClientFactory;
189use MediaWiki\Site\CachingSiteStore;
190use MediaWiki\Site\DBSiteStore;
191use MediaWiki\Site\SiteLookup;
192use MediaWiki\Site\SiteStore;
193use MediaWiki\SpecialPage\SpecialPageFactory;
194use MediaWiki\Storage\BlobStore;
195use MediaWiki\Storage\BlobStoreFactory;
196use MediaWiki\Storage\EditResultCache;
197use MediaWiki\Storage\NameTableStore;
198use MediaWiki\Storage\NameTableStoreFactory;
199use MediaWiki\Storage\PageEditStash;
200use MediaWiki\Storage\PageUpdaterFactory;
201use MediaWiki\Storage\RevertedTagUpdateManager;
202use MediaWiki\Storage\SqlBlobStore;
203use MediaWiki\Tidy\RemexDriver;
204use MediaWiki\Tidy\TidyDriverBase;
205use MediaWiki\Title\MediaWikiTitleCodec;
206use MediaWiki\Title\NamespaceInfo;
207use MediaWiki\Title\TitleFactory;
208use MediaWiki\Title\TitleFormatter;
209use MediaWiki\Title\TitleParser;
210use MediaWiki\User\ActorMigration;
211use MediaWiki\User\ActorNormalization;
212use MediaWiki\User\ActorStore;
213use MediaWiki\User\ActorStoreFactory;
214use MediaWiki\User\BotPasswordStore;
215use MediaWiki\User\CentralId\CentralIdLookup;
216use MediaWiki\User\CentralId\CentralIdLookupFactory;
217use MediaWiki\User\Options\ConditionalDefaultsLookup;
218use MediaWiki\User\Options\DefaultOptionsLookup;
219use MediaWiki\User\Options\UserOptionsLookup;
220use MediaWiki\User\Options\UserOptionsManager;
221use MediaWiki\User\PasswordReset;
222use MediaWiki\User\Registration\LocalUserRegistrationProvider;
223use MediaWiki\User\Registration\UserRegistrationLookup;
224use MediaWiki\User\TalkPageNotificationManager;
225use MediaWiki\User\TempUser\RealTempUserConfig;
226use MediaWiki\User\TempUser\TempUserCreator;
227use MediaWiki\User\UserEditTracker;
228use MediaWiki\User\UserFactory;
229use MediaWiki\User\UserGroupManager;
230use MediaWiki\User\UserGroupManagerFactory;
231use MediaWiki\User\UserIdentity;
232use MediaWiki\User\UserIdentityLookup;
233use MediaWiki\User\UserIdentityUtils;
234use MediaWiki\User\UserNamePrefixSearch;
235use MediaWiki\User\UserNameUtils;
236use MediaWiki\Utils\UrlUtils;
237use MediaWiki\Watchlist\WatchlistManager;
238use MediaWiki\WikiMap\WikiMap;
239use Wikimedia\DependencyStore\KeyValueDependencyStore;
240use Wikimedia\DependencyStore\SqlModuleDependencyStore;
241use Wikimedia\EventRelayer\EventRelayerGroup;
242use Wikimedia\Message\IMessageFormatterFactory;
243use Wikimedia\ObjectFactory\ObjectFactory;
244use Wikimedia\Parsoid\Config\DataAccess;
245use Wikimedia\Parsoid\Config\SiteConfig;
246use Wikimedia\Parsoid\Parsoid;
247use Wikimedia\Rdbms\ChronologyProtector;
248use Wikimedia\Rdbms\ConfiguredReadOnlyMode;
249use Wikimedia\Rdbms\DatabaseFactory;
250use Wikimedia\Rdbms\IConnectionProvider;
251use Wikimedia\Rdbms\ReadOnlyMode;
252use Wikimedia\RequestTimeout\CriticalSectionProvider;
253use Wikimedia\RequestTimeout\RequestTimeout;
254use Wikimedia\Stats\StatsCache;
255use Wikimedia\Stats\StatsFactory;
256use Wikimedia\UUID\GlobalIdGenerator;
257use Wikimedia\WRStats\BagOStuffStatsStore;
258use Wikimedia\WRStats\WRStatsFactory;
259
260/** @phpcs-require-sorted-array */
261return [
262    'ActionFactory' => static function ( MediaWikiServices $services ): ActionFactory {
263        return new ActionFactory(
264            $services->getMainConfig()->get( MainConfigNames::Actions ),
265            LoggerFactory::getInstance( 'ActionFactory' ),
266            $services->getObjectFactory(),
267            $services->getHookContainer()
268        );
269    },
270
271    'ActorMigration' => static function ( MediaWikiServices $services ): ActorMigration {
272        return new ActorMigration(
273            $services->getActorStoreFactory()
274        );
275    },
276
277    'ActorNormalization' => static function ( MediaWikiServices $services ): ActorNormalization {
278        return $services->getActorStoreFactory()->getActorNormalization();
279    },
280
281    'ActorStore' => static function ( MediaWikiServices $services ): ActorStore {
282        return $services->getActorStoreFactory()->getActorStore();
283    },
284
285    'ActorStoreFactory' => static function ( MediaWikiServices $services ): ActorStoreFactory {
286        return new ActorStoreFactory(
287            new ServiceOptions( ActorStoreFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
288            $services->getDBLoadBalancerFactory(),
289            $services->getUserNameUtils(),
290            $services->getTempUserConfig(),
291            LoggerFactory::getInstance( 'ActorStore' ),
292            $services->getHideUserUtils()
293        );
294    },
295
296    'ArchivedRevisionLookup' => static function ( MediaWikiServices $services ): ArchivedRevisionLookup {
297        return new ArchivedRevisionLookup(
298            $services->getConnectionProvider(),
299            $services->getRevisionStore()
300        );
301    },
302
303    'AuthManager' => static function ( MediaWikiServices $services ): AuthManager {
304        $authManager = new AuthManager(
305            RequestContext::getMain()->getRequest(),
306            $services->getMainConfig(),
307            $services->getObjectFactory(),
308            $services->getHookContainer(),
309            $services->getReadOnlyMode(),
310            $services->getUserNameUtils(),
311            $services->getBlockManager(),
312            $services->getWatchlistManager(),
313            $services->getDBLoadBalancer(),
314            $services->getContentLanguage(),
315            $services->getLanguageConverterFactory(),
316            $services->getBotPasswordStore(),
317            $services->getUserFactory(),
318            $services->getUserIdentityLookup(),
319            $services->getUserOptionsManager()
320        );
321        $authManager->setLogger( LoggerFactory::getInstance( 'authentication' ) );
322        return $authManager;
323    },
324
325    'AutoblockExemptionList' => static function ( MediaWikiServices $services ): AutoblockExemptionList {
326        $messageFormatterFactory = new MessageFormatterFactory( Message::FORMAT_PLAIN );
327        return new AutoblockExemptionList(
328            LoggerFactory::getInstance( 'AutoblockExemptionList' ),
329            $messageFormatterFactory->getTextFormatter(
330                $services->getContentLanguage()->getCode()
331            )
332        );
333    },
334
335    'BacklinkCacheFactory' => static function ( MediaWikiServices $services ): BacklinkCacheFactory {
336        return new BacklinkCacheFactory(
337            new ServiceOptions(
338                BacklinkCache::CONSTRUCTOR_OPTIONS,
339                $services->getMainConfig()
340            ),
341            $services->getLinksMigration(),
342            $services->getMainWANObjectCache(),
343            $services->getHookContainer(),
344            $services->getConnectionProvider()
345        );
346    },
347
348    'BadFileLookup' => static function ( MediaWikiServices $services ): BadFileLookup {
349        return new BadFileLookup(
350            static function () {
351                return wfMessage( 'bad_image_list' )->inContentLanguage()->plain();
352            },
353            $services->getLocalServerObjectCache(),
354            $services->getRepoGroup(),
355            $services->getTitleParser(),
356            $services->getHookContainer()
357        );
358    },
359
360    'BlobStore' => static function ( MediaWikiServices $services ): BlobStore {
361        return $services->getService( '_SqlBlobStore' );
362    },
363
364    'BlobStoreFactory' => static function ( MediaWikiServices $services ): BlobStoreFactory {
365        return new BlobStoreFactory(
366            $services->getDBLoadBalancerFactory(),
367            $services->getExternalStoreAccess(),
368            $services->getMainWANObjectCache(),
369            new ServiceOptions( BlobStoreFactory::CONSTRUCTOR_OPTIONS,
370                $services->getMainConfig() )
371        );
372    },
373
374    'BlockActionInfo' => static function ( MediaWikiServices $services ): BlockActionInfo {
375        return new BlockActionInfo( $services->getHookContainer() );
376    },
377
378    'BlockErrorFormatter' => static function ( MediaWikiServices $services ): BlockErrorFormatter {
379        return $services->getFormatterFactory()->getBlockErrorFormatter(
380            new LazyLocalizationContext( static function () {
381                return RequestContext::getMain();
382            } )
383        );
384    },
385
386    'BlockManager' => static function ( MediaWikiServices $services ): BlockManager {
387        return new BlockManager(
388            new ServiceOptions(
389                BlockManager::CONSTRUCTOR_OPTIONS,
390                $services->getMainConfig()
391            ),
392            $services->getUserFactory(),
393            $services->getUserIdentityUtils(),
394            LoggerFactory::getInstance( 'BlockManager' ),
395            $services->getHookContainer(),
396            $services->getDatabaseBlockStore(),
397            $services->getProxyLookup()
398        );
399    },
400
401    'BlockPermissionCheckerFactory' => static function (
402        MediaWikiServices $services
403    ): BlockPermissionCheckerFactory {
404        return new BlockPermissionCheckerFactory(
405            new ServiceOptions(
406                BlockPermissionCheckerFactory::CONSTRUCTOR_OPTIONS,
407                $services->getMainConfig()
408            ),
409            $services->getBlockUtils()
410        );
411    },
412
413    'BlockRestrictionStore' => static function ( MediaWikiServices $services ): BlockRestrictionStore {
414        return $services->getBlockRestrictionStoreFactory()->getBlockRestrictionStore( WikiAwareEntity::LOCAL );
415    },
416
417    'BlockRestrictionStoreFactory' => static function ( MediaWikiServices $services ): BlockRestrictionStoreFactory {
418        return new BlockRestrictionStoreFactory(
419            $services->getDBLoadBalancerFactory(),
420            $services->getMainConfig()->get( MainConfigNames::BlockTargetMigrationStage )
421        );
422    },
423
424    'BlockUserFactory' => static function ( MediaWikiServices $services ): BlockUserFactory {
425        return $services->getService( '_UserBlockCommandFactory' );
426    },
427
428    'BlockUtils' => static function ( MediaWikiServices $services ): BlockUtils {
429        return $services->getBlockUtilsFactory()->getBlockUtils();
430    },
431
432    'BlockUtilsFactory' => static function ( MediaWikiServices $services ): BlockUtilsFactory {
433        return new BlockUtilsFactory(
434            new ServiceOptions(
435                BlockUtilsFactory::CONSTRUCTOR_OPTIONS,
436                $services->getMainConfig()
437            ),
438            $services->getActorStoreFactory(),
439            $services->getUserNameUtils(),
440            $services->getDBLoadBalancerFactory()
441        );
442    },
443
444    'BotPasswordStore' => static function ( MediaWikiServices $services ): BotPasswordStore {
445        return new BotPasswordStore(
446            new ServiceOptions(
447                BotPasswordStore::CONSTRUCTOR_OPTIONS,
448                $services->getMainConfig()
449            ),
450            $services->getCentralIdLookup(),
451            $services->getDBLoadBalancerFactory()
452        );
453    },
454
455    'CentralIdLookup' => static function ( MediaWikiServices $services ): CentralIdLookup {
456        return $services->getCentralIdLookupFactory()->getLookup();
457    },
458
459    'CentralIdLookupFactory' => static function ( MediaWikiServices $services ): CentralIdLookupFactory {
460        return new CentralIdLookupFactory(
461            new ServiceOptions( CentralIdLookupFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
462            $services->getObjectFactory(),
463            $services->getUserIdentityLookup(),
464            $services->getUserFactory()
465        );
466    },
467
468    'ChangeTagDefStore' => static function ( MediaWikiServices $services ): NameTableStore {
469        return $services->getNameTableStoreFactory()->getChangeTagDef();
470    },
471
472    'ChangeTagsStore' => static function ( MediaWikiServices $services ): ChangeTagsStore {
473        return new ChangeTagsStore(
474            $services->getConnectionProvider(),
475            $services->getChangeTagDefStore(),
476            $services->getMainWANObjectCache(),
477            $services->getHookContainer(),
478            LoggerFactory::getInstance( 'ChangeTags' ),
479            $services->getUserFactory(),
480            new ServiceOptions(
481                ChangeTagsStore::CONSTRUCTOR_OPTIONS,
482                $services->getMainConfig()
483            )
484        );
485    },
486
487    'ChronologyProtector' => static function ( MediaWikiServices $services ): ChronologyProtector {
488        $mainConfig = $services->getMainConfig();
489        $cpStashType = $mainConfig->get( MainConfigNames::ChronologyProtectorStash );
490        $isMainCacheBad = ObjectCache::isDatabaseId( $mainConfig->get( MainConfigNames::MainCacheType ) );
491
492        if ( is_string( $cpStashType ) ) {
493            $cpStash = ObjectCache::getInstance( $cpStashType );
494        } elseif ( $isMainCacheBad ) {
495            $cpStash = new EmptyBagOStuff();
496        } else {
497            $cpStash = ObjectCache::getLocalClusterInstance();
498        }
499
500        $chronologyProtector = new ChronologyProtector(
501            $cpStash,
502            $mainConfig->get( MainConfigNames::ChronologyProtectorSecret ),
503            MW_ENTRY_POINT === 'cli',
504            LoggerFactory::getInstance( 'rdbms' )
505        );
506
507        // Use the global WebRequest singleton. The main reason for using this
508        // is to call WebRequest::getIP() which is non-trivial to reproduce statically
509        // because it needs $wgUsePrivateIPs, as well as ProxyLookup and HookRunner services.
510        // TODO: Create a static version of WebRequest::getIP that accepts these three
511        // as dependencies, and then call that here. The other uses of $req below can
512        // trivially use $_COOKIES, $_GET and $_SERVER instead.
513        $req = RequestContext::getMain()->getRequest();
514
515        // Set user IP/agent information for agent session consistency purposes
516        $reqStart = (int)( $_SERVER['REQUEST_TIME_FLOAT'] ?? time() );
517        $cpPosInfo = ChronologyProtector::getCPInfoFromCookieValue(
518        // The cookie has no prefix and is set by MediaWiki::preOutputCommit()
519            $req->getCookie( 'cpPosIndex', '' ),
520            // Mitigate broken client-side cookie expiration handling (T190082)
521            $reqStart - ChronologyProtector::POSITION_COOKIE_TTL
522        );
523        $chronologyProtector->setRequestInfo( [
524            'IPAddress' => $req->getIP(),
525            'UserAgent' => $req->getHeader( 'User-Agent' ),
526            'ChronologyPositionIndex' => $req->getInt( 'cpPosIndex', $cpPosInfo['index'] ),
527            'ChronologyClientId' => $cpPosInfo['clientId'] ?? null,
528        ] );
529        return $chronologyProtector;
530    },
531
532    'CollationFactory' => static function ( MediaWikiServices $services ): CollationFactory {
533        return new CollationFactory(
534            new ServiceOptions(
535                CollationFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
536            $services->getObjectFactory(),
537            $services->getHookContainer()
538        );
539    },
540
541    'CommentFormatter' => static function ( MediaWikiServices $services ): CommentFormatter {
542        return new CommentFormatter(
543            $services->getCommentParserFactory()
544        );
545    },
546
547    'CommentParserFactory' => static function ( MediaWikiServices $services ): CommentParserFactory {
548        return new CommentParserFactory(
549            $services->getLinkRendererFactory()->create( [ 'renderForComment' => true ] ),
550            $services->getLinkBatchFactory(),
551            $services->getLinkCache(),
552            $services->getRepoGroup(),
553            RequestContext::getMain()->getLanguage(),
554            $services->getContentLanguage(),
555            $services->getTitleParser(),
556            $services->getNamespaceInfo(),
557            $services->getHookContainer()
558        );
559    },
560
561    'CommentStore' => static function ( MediaWikiServices $services ): CommentStore {
562        return new CommentStore( $services->getContentLanguage() );
563    },
564
565    'ConfigFactory' => static function ( MediaWikiServices $services ): ConfigFactory {
566        // Use the bootstrap config to initialize the ConfigFactory.
567        $registry = $services->getBootstrapConfig()->get( MainConfigNames::ConfigRegistry );
568        $factory = new ConfigFactory();
569
570        foreach ( $registry as $name => $callback ) {
571            $factory->register( $name, $callback );
572        }
573        return $factory;
574    },
575
576    'ConfigRepository' => static function ( MediaWikiServices $services ): ConfigRepository {
577        return new ConfigRepository( $services->getConfigFactory() );
578    },
579
580    'ConfigSchema' => static function ( MediaWikiServices $services ): ConfigSchema {
581        /** @var SettingsBuilder $settings */
582        $settings = $services->get( '_SettingsBuilder' );
583        return $settings->getConfigSchema();
584    },
585
586    'ConfiguredReadOnlyMode' => static function ( MediaWikiServices $services ): ConfiguredReadOnlyMode {
587        $config = $services->getMainConfig();
588        return new ConfiguredReadOnlyMode(
589            $config->get( MainConfigNames::ReadOnly ),
590            $config->get( MainConfigNames::ReadOnlyFile )
591        );
592    },
593
594    'ConnectionProvider' => static function ( MediaWikiServices $services ): IConnectionProvider {
595        return $services->getDBLoadBalancerFactory();
596    },
597
598    'ContentHandlerFactory' => static function ( MediaWikiServices $services ): IContentHandlerFactory {
599        $contentHandlerConfig = $services->getMainConfig()->get( MainConfigNames::ContentHandlers );
600
601        return new ContentHandlerFactory(
602            $contentHandlerConfig,
603            $services->getObjectFactory(),
604            $services->getHookContainer(),
605            LoggerFactory::getInstance( 'ContentHandler' )
606        );
607    },
608
609    'ContentLanguage' => static function ( MediaWikiServices $services ): Language {
610        return $services->getLanguageFactory()->getLanguage(
611            $services->getMainConfig()->get( MainConfigNames::LanguageCode ) );
612    },
613
614    'ContentModelChangeFactory' => static function ( MediaWikiServices $services ): ContentModelChangeFactory {
615        return $services->getService( '_PageCommandFactory' );
616    },
617
618    'ContentModelStore' => static function ( MediaWikiServices $services ): NameTableStore {
619        return $services->getNameTableStoreFactory()->getContentModels();
620    },
621
622    'ContentRenderer' => static function ( MediaWikiServices $services ): ContentRenderer {
623        return new ContentRenderer(
624            $services->getContentHandlerFactory(),
625            $services->getGlobalIdGenerator()
626        );
627    },
628
629    'ContentTransformer' => static function ( MediaWikiServices $services ): ContentTransformer {
630        return new ContentTransformer( $services->getContentHandlerFactory() );
631    },
632
633    'ContributionsLookup' => static function ( MediaWikiServices $services ): ContributionsLookup {
634        return new ContributionsLookup(
635            $services->getRevisionStore(),
636            $services->getLinkRendererFactory(),
637            $services->getLinkBatchFactory(),
638            $services->getHookContainer(),
639            $services->getConnectionProvider(),
640            $services->getNamespaceInfo(),
641            $services->getCommentFormatter()
642        );
643    },
644
645    'CriticalSectionProvider' => static function ( MediaWikiServices $services ): CriticalSectionProvider {
646        $config = $services->getMainConfig();
647        $limit = MW_ENTRY_POINT === 'cli' ? INF : $config->get( MainConfigNames::CriticalSectionTimeLimit );
648        return RequestTimeout::singleton()->createCriticalSectionProvider( $limit );
649    },
650
651    'CryptHKDF' => static function ( MediaWikiServices $services ): CryptHKDF {
652        $config = $services->getMainConfig();
653
654        $secret = $config->get( MainConfigNames::HKDFSecret ) ?: $config->get( MainConfigNames::SecretKey );
655        if ( !$secret ) {
656            throw new RuntimeException( "Cannot use MWCryptHKDF without a secret." );
657        }
658
659        // In HKDF, the context can be known to the attacker, but this will
660        // keep simultaneous runs from producing the same output.
661        $context = [ microtime(), getmypid(), gethostname() ];
662
663        // Setup salt cache. Use APC, or fallback to the main cache if it isn't setup
664        $cache = $services->getLocalServerObjectCache();
665        if ( $cache instanceof EmptyBagOStuff ) {
666            $cache = ObjectCache::getLocalClusterInstance();
667        }
668
669        return new CryptHKDF( $secret, $config->get( MainConfigNames::HKDFAlgorithm ), $cache, $context );
670    },
671
672    'DatabaseBlockStore' => static function ( MediaWikiServices $services ): DatabaseBlockStore {
673        return $services->getDatabaseBlockStoreFactory()->getDatabaseBlockStore( DatabaseBlock::LOCAL );
674    },
675
676    'DatabaseBlockStoreFactory' => static function ( MediaWikiServices $services ): DatabaseBlockStoreFactory {
677        return new DatabaseBlockStoreFactory(
678            new ServiceOptions(
679                DatabaseBlockStoreFactory::CONSTRUCTOR_OPTIONS,
680                $services->getMainConfig()
681            ),
682            LoggerFactory::getInstance( 'DatabaseBlockStore' ),
683            $services->getActorStoreFactory(),
684            $services->getBlockRestrictionStoreFactory(),
685            $services->getCommentStore(),
686            $services->getHookContainer(),
687            $services->getDBLoadBalancerFactory(),
688            $services->getReadOnlyMode(),
689            $services->getUserFactory(),
690            $services->getTempUserConfig(),
691            $services->getBlockUtilsFactory(),
692            $services->getAutoblockExemptionList()
693        );
694    },
695
696    'DatabaseFactory' => static function ( MediaWikiServices $services ): DatabaseFactory {
697        return new DatabaseFactory(
698            [ 'debugSql' => $services->getMainConfig()->get( MainConfigNames::DebugDumpSql ) ]
699        );
700    },
701
702    'DateFormatterFactory' => static function ( MediaWikiServices $services ): DateFormatterFactory {
703        return new DateFormatterFactory();
704    },
705
706    'DBLoadBalancer' => static function ( MediaWikiServices $services ): Wikimedia\Rdbms\ILoadBalancer {
707        // just return the default LB from the DBLoadBalancerFactory service
708        return $services->getDBLoadBalancerFactory()->getMainLB();
709    },
710
711    'DBLoadBalancerFactory' => static function ( MediaWikiServices $services ): Wikimedia\Rdbms\LBFactory {
712        $mainConfig = $services->getMainConfig();
713        $lbFactoryConfigBuilder = $services->getDBLoadBalancerFactoryConfigBuilder();
714
715        $lbConf = $lbFactoryConfigBuilder->applyDefaultConfig(
716            $mainConfig->get( MainConfigNames::LBFactoryConf )
717        );
718
719        $class = $lbFactoryConfigBuilder->getLBFactoryClass( $lbConf );
720        $instance = new $class( $lbConf );
721
722        $lbFactoryConfigBuilder->setDomainAliases( $instance );
723
724        // NOTE: This accesses ProxyLookup from the MediaWikiServices singleton
725        // for non-essential non-nonimal purposes (via WebRequest::getIP).
726        // This state is fine (and meant) to be consistent for a given PHP process,
727        // even if applied to the service container for a different wiki.
728        $lbFactoryConfigBuilder->applyGlobalState(
729            $instance,
730            $mainConfig,
731            $services->getStatsdDataFactory()
732        );
733
734        return $instance;
735    },
736
737    'DBLoadBalancerFactoryConfigBuilder' => static function ( MediaWikiServices $services ): MWLBFactory {
738        $mainConfig = $services->getMainConfig();
739        if ( ObjectCache::isDatabaseId( $mainConfig->get( MainConfigNames::MainCacheType ) ) ) {
740            $wanCache = WANObjectCache::newEmpty();
741        } else {
742            $wanCache = $services->getMainWANObjectCache();
743        }
744        $srvCache = $services->getLocalServerObjectCache();
745        if ( $srvCache instanceof EmptyBagOStuff ) {
746            // Use process cache if no APCU or other local-server cache (e.g. on CLI)
747            $srvCache = new HashBagOStuff( [ 'maxKeys' => 100 ] );
748        }
749
750        return new MWLBFactory(
751            new ServiceOptions( MWLBFactory::APPLY_DEFAULT_CONFIG_OPTIONS, $services->getMainConfig() ),
752            new ConfiguredReadOnlyMode(
753                $mainConfig->get( MainConfigNames::ReadOnly ),
754                $mainConfig->get( MainConfigNames::ReadOnlyFile )
755            ),
756            $services->getChronologyProtector(),
757            $srvCache,
758            $wanCache,
759            $services->getCriticalSectionProvider(),
760            $services->getStatsdDataFactory(),
761            ExtensionRegistry::getInstance()->getAttribute( 'DatabaseVirtualDomains' )
762        );
763    },
764
765    'DefaultOutputPipeline' => static function ( MediaWikiServices $services ): OutputTransformPipeline {
766        return ( new DefaultOutputPipelineFactory(
767            $services->getHookContainer(),
768            $services->getTidy(),
769            $services->getLanguageFactory(),
770            $services->getContentLanguage(),
771            LoggerFactory::getInstance( 'Parser' ),
772            $services->getTitleFactory()
773        ) )->buildPipeline();
774    },
775
776    'DeletePageFactory' => static function ( MediaWikiServices $services ): DeletePageFactory {
777        return $services->getService( '_PageCommandFactory' );
778    },
779
780    'Emailer' => static function ( MediaWikiServices $services ): IEmailer {
781        return new Emailer();
782    },
783
784    'EmailUserFactory' => static function ( MediaWikiServices $services ): EmailUserFactory {
785        return new EmailUserFactory(
786            new ServiceOptions( EmailUser::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
787            $services->getHookContainer(),
788            $services->getUserOptionsLookup(),
789            $services->getCentralIdLookup(),
790            $services->getUserFactory(),
791            $services->getEmailer(),
792            $services->getMessageFormatterFactory(),
793            $services->getMessageFormatterFactory()->getTextFormatter( $services->getContentLanguage()->getCode() )
794        );
795    },
796
797    'EventRelayerGroup' => static function ( MediaWikiServices $services ): EventRelayerGroup {
798        return new EventRelayerGroup( $services->getMainConfig()->get( MainConfigNames::EventRelayerConfig ) );
799    },
800
801    'ExtensionRegistry' => static function ( MediaWikiServices $services ): ExtensionRegistry {
802        return ExtensionRegistry::getInstance();
803    },
804
805    'ExternalStoreAccess' => static function ( MediaWikiServices $services ): ExternalStoreAccess {
806        return new ExternalStoreAccess(
807            $services->getExternalStoreFactory(),
808            LoggerFactory::getInstance( 'ExternalStore' )
809        );
810    },
811
812    'ExternalStoreFactory' => static function ( MediaWikiServices $services ): ExternalStoreFactory {
813        $config = $services->getMainConfig();
814        $writeStores = $config->get( MainConfigNames::DefaultExternalStore );
815
816        return new ExternalStoreFactory(
817            $config->get( MainConfigNames::ExternalStores ),
818            ( $writeStores !== false ) ? (array)$writeStores : [],
819            $services->getDBLoadBalancer()->getLocalDomainID(),
820            LoggerFactory::getInstance( 'ExternalStore' )
821        );
822    },
823
824    'FileBackendGroup' => static function ( MediaWikiServices $services ): FileBackendGroup {
825        $mainConfig = $services->getMainConfig();
826
827        $ld = WikiMap::getCurrentWikiDbDomain();
828        $fallbackWikiId = WikiMap::getWikiIdFromDbDomain( $ld );
829        // If the local wiki ID and local domain ID do not match, probably due to a non-default
830        // schema, issue a warning. A non-default schema indicates that it might be used to
831        // disambiguate different wikis.
832        $legacyDomainId = strlen( $ld->getTablePrefix() )
833            ? "{$ld->getDatabase()}-{$ld->getTablePrefix()}"
834            : $ld->getDatabase();
835        if ( $ld->getSchema() !== null && $legacyDomainId !== $fallbackWikiId ) {
836            wfWarn(
837                "Legacy default 'domainId' is '$legacyDomainId' but wiki ID is '$fallbackWikiId'."
838            );
839        }
840
841        $cache = $services->getLocalServerObjectCache();
842        if ( $cache instanceof EmptyBagOStuff ) {
843            $cache = new HashBagOStuff();
844        }
845
846        return new FileBackendGroup(
847            new ServiceOptions( FileBackendGroup::CONSTRUCTOR_OPTIONS, $mainConfig,
848                [ 'fallbackWikiId' => $fallbackWikiId ] ),
849            $services->getReadOnlyMode(),
850            $cache,
851            $services->getMainWANObjectCache(),
852            $services->getMimeAnalyzer(),
853            $services->getLockManagerGroupFactory(),
854            $services->getTempFSFileFactory(),
855            $services->getObjectFactory()
856        );
857    },
858
859    'FormatterFactory' => static function ( MediaWikiServices $services ): FormatterFactory {
860        return new FormatterFactory(
861            $services->getMessageCache(),
862            $services->getTitleFormatter(),
863            $services->getHookContainer(),
864            $services->getUserIdentityUtils(),
865            $services->getLanguageFactory()
866        );
867    },
868
869    'GenderCache' => static function ( MediaWikiServices $services ): GenderCache {
870        $nsInfo = $services->getNamespaceInfo();
871        // Database layer may be disabled, so processing without database connection
872        $dbLoadBalancer = $services->isServiceDisabled( 'DBLoadBalancer' )
873            ? null
874            : $services->getDBLoadBalancerFactory();
875        return new GenderCache( $nsInfo, $dbLoadBalancer, $services->get( '_DefaultOptionsLookup' ) );
876    },
877
878    'GlobalIdGenerator' => static function ( MediaWikiServices $services ): GlobalIdGenerator {
879        $mainConfig = $services->getMainConfig();
880
881        return new GlobalIdGenerator(
882            $mainConfig->get( MainConfigNames::TmpDirectory ),
883            static function ( $command ) {
884                return wfShellExec( $command );
885            }
886        );
887    },
888
889    'GrantsInfo' => static function ( MediaWikiServices $services ): GrantsInfo {
890        return new GrantsInfo(
891            new ServiceOptions(
892                GrantsInfo::CONSTRUCTOR_OPTIONS,
893                $services->getMainConfig()
894            )
895        );
896    },
897
898    'GrantsLocalization' => static function ( MediaWikiServices $services ): GrantsLocalization {
899        return new GrantsLocalization(
900            $services->getGrantsInfo(),
901            $services->getLinkRenderer(),
902            $services->getLanguageFactory(),
903            $services->getContentLanguage()
904        );
905    },
906
907    'GroupPermissionsLookup' => static function ( MediaWikiServices $services ): GroupPermissionsLookup {
908        return new GroupPermissionsLookup(
909            new ServiceOptions( GroupPermissionsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig() )
910        );
911    },
912
913    'HideUserUtils' => static function ( MediaWikiServices $services ): HideUserUtils {
914        return new HideUserUtils(
915            $services->getMainConfig()->get( MainConfigNames::BlockTargetMigrationStage )
916        );
917    },
918
919    'HookContainer' => static function ( MediaWikiServices $services ): HookContainer {
920        // NOTE: This is called while $services is being initialized, in order to call the
921        //       MediaWikiServices hook.
922
923        $configHooks = $services->getBootstrapConfig()->get( MainConfigNames::Hooks );
924
925        // If we are instantiating this service after $wgHooks was replaced by a fake,
926        // get the original array out of the object. This should only happen in the installer,
927        // when it calls resetMediaWikiServices().
928        if ( $configHooks instanceof FauxGlobalHookArray ) {
929            $configHooks = $configHooks->getOriginalArray();
930        }
931
932        $extRegistry = ExtensionRegistry::getInstance();
933        $extHooks = $extRegistry->getAttribute( 'Hooks' );
934        $extDeprecatedHooks = $extRegistry->getAttribute( 'DeprecatedHooks' );
935
936        $hookRegistry = new StaticHookRegistry( $configHooks, $extHooks, $extDeprecatedHooks );
937        $hookContainer = new HookContainer(
938            $hookRegistry,
939            $services->getObjectFactory()
940        );
941
942        return $hookContainer;
943    },
944
945    'HtmlCacheUpdater' => static function ( MediaWikiServices $services ): HTMLCacheUpdater {
946        $config = $services->getMainConfig();
947
948        return new HTMLCacheUpdater(
949            $services->getHookContainer(),
950            $services->getTitleFactory(),
951            $config->get( MainConfigNames::CdnReboundPurgeDelay ),
952            $config->get( MainConfigNames::UseFileCache ),
953            $config->get( MainConfigNames::CdnMaxAge )
954        );
955    },
956
957    'HtmlTransformFactory' => static function ( MediaWikiServices $services ): HtmlTransformFactory {
958        return new HtmlTransformFactory(
959            $services->getService( '_Parsoid' ),
960            $services->getMainConfig()->get( MainConfigNames::ParsoidSettings ),
961            $services->getParsoidPageConfigFactory(),
962            $services->getContentHandlerFactory(),
963            $services->getParsoidSiteConfig(),
964            $services->getTitleFactory(),
965            $services->getLanguageConverterFactory(),
966            $services->getLanguageFactory()
967        );
968    },
969
970    'HttpRequestFactory' => static function ( MediaWikiServices $services ): HttpRequestFactory {
971        return new HttpRequestFactory(
972            new ServiceOptions(
973                HttpRequestFactory::CONSTRUCTOR_OPTIONS,
974                $services->getMainConfig()
975            ),
976            LoggerFactory::getInstance( 'http' ),
977            Telemetry::getInstance()
978        );
979    },
980
981    'InterwikiLookup' => static function ( MediaWikiServices $services ): InterwikiLookup {
982        return new ClassicInterwikiLookup(
983            new ServiceOptions(
984                ClassicInterwikiLookup::CONSTRUCTOR_OPTIONS,
985                $services->getMainConfig(),
986                [ 'wikiId' => WikiMap::getCurrentWikiId() ]
987            ),
988            $services->getContentLanguage(),
989            $services->getMainWANObjectCache(),
990            $services->getHookContainer(),
991            $services->getConnectionProvider()
992        );
993    },
994
995    'IntroMessageBuilder' => static function ( MediaWikiServices $services ): IntroMessageBuilder {
996        return new IntroMessageBuilder(
997            $services->getMainConfig(),
998            $services->getLinkRenderer(),
999            $services->getPermissionManager(),
1000            $services->getUserNameUtils(),
1001            $services->getTempUserCreator(),
1002            $services->getUserFactory(),
1003            $services->getRestrictionStore(),
1004            $services->getDatabaseBlockStore(),
1005            $services->getReadOnlyMode(),
1006            $services->getSpecialPageFactory(),
1007            $services->getRepoGroup(),
1008            $services->getNamespaceInfo(),
1009            $services->getSkinFactory(),
1010            $services->getConnectionProvider()
1011        );
1012    },
1013
1014    'JobFactory' => static function ( MediaWikiServices $services ): JobFactory {
1015        return new JobFactory(
1016            $services->getObjectFactory(),
1017            $services->getMainConfig()->get( MainConfigNames::JobClasses )
1018        );
1019    },
1020
1021    'JobQueueGroup' => static function ( MediaWikiServices $services ): JobQueueGroup {
1022        return $services->getJobQueueGroupFactory()->makeJobQueueGroup();
1023    },
1024
1025    'JobQueueGroupFactory' => static function ( MediaWikiServices $services ): JobQueueGroupFactory {
1026        return new JobQueueGroupFactory(
1027            new ServiceOptions( JobQueueGroupFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1028            $services->getReadOnlyMode(),
1029            $services->getStatsdDataFactory(),
1030            $services->getMainWANObjectCache(),
1031            $services->getGlobalIdGenerator()
1032        );
1033    },
1034
1035    'JobRunner' => static function ( MediaWikiServices $services ): JobRunner {
1036        return new JobRunner(
1037            new ServiceOptions( JobRunner::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1038            $services->getDBLoadBalancerFactory(),
1039            $services->getJobQueueGroup(),
1040            $services->getReadOnlyMode(),
1041            $services->getLinkCache(),
1042            $services->getStatsdDataFactory(),
1043            LoggerFactory::getInstance( 'runJobs' )
1044        );
1045    },
1046
1047    'JsonCodec' => static function ( MediaWikiServices $services ): JsonCodec {
1048        return new JsonCodec();
1049    },
1050
1051    'LanguageConverterFactory' => static function ( MediaWikiServices $services ): LanguageConverterFactory {
1052        return new LanguageConverterFactory(
1053            new ServiceOptions( LanguageConverterFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1054            $services->getObjectFactory(),
1055            static function () use ( $services ) {
1056                return $services->getContentLanguage();
1057            }
1058        );
1059    },
1060
1061    'LanguageFactory' => static function ( MediaWikiServices $services ): LanguageFactory {
1062        return new LanguageFactory(
1063            new ServiceOptions( LanguageFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1064            $services->getNamespaceInfo(),
1065            $services->getLocalisationCache(),
1066            $services->getLanguageNameUtils(),
1067            $services->getLanguageFallback(),
1068            $services->getLanguageConverterFactory(),
1069            $services->getHookContainer(),
1070            $services->getMainConfig()
1071        );
1072    },
1073
1074    'LanguageFallback' => static function ( MediaWikiServices $services ): LanguageFallback {
1075        return new LanguageFallback(
1076            $services->getMainConfig()->get( MainConfigNames::LanguageCode ),
1077            $services->getLocalisationCache(),
1078            $services->getLanguageNameUtils()
1079        );
1080    },
1081
1082    'LanguageNameUtils' => static function ( MediaWikiServices $services ): LanguageNameUtils {
1083        return new LanguageNameUtils(
1084            new ServiceOptions(
1085                LanguageNameUtils::CONSTRUCTOR_OPTIONS,
1086                $services->getMainConfig()
1087            ),
1088            $services->getHookContainer()
1089        );
1090    },
1091
1092    'LinkBatchFactory' => static function ( MediaWikiServices $services ): LinkBatchFactory {
1093        return new LinkBatchFactory(
1094            $services->getLinkCache(),
1095            $services->getTitleFormatter(),
1096            $services->getContentLanguage(),
1097            $services->getGenderCache(),
1098            $services->getConnectionProvider(),
1099            $services->getLinksMigration(),
1100            LoggerFactory::getInstance( 'LinkBatch' )
1101        );
1102    },
1103
1104    'LinkCache' => static function ( MediaWikiServices $services ): LinkCache {
1105        // Database layer may be disabled, so processing without database connection
1106        $dbLoadBalancer = $services->isServiceDisabled( 'DBLoadBalancer' )
1107            ? null
1108            : $services->getDBLoadBalancer();
1109        $linkCache = new LinkCache(
1110            $services->getTitleFormatter(),
1111            $services->getMainWANObjectCache(),
1112            $services->getNamespaceInfo(),
1113            $dbLoadBalancer
1114        );
1115        $linkCache->setLogger( LoggerFactory::getInstance( 'LinkCache' ) );
1116        return $linkCache;
1117    },
1118
1119    'LinkRenderer' => static function ( MediaWikiServices $services ): LinkRenderer {
1120        return $services->getLinkRendererFactory()->create();
1121    },
1122
1123    'LinkRendererFactory' => static function ( MediaWikiServices $services ): LinkRendererFactory {
1124        return new LinkRendererFactory(
1125            $services->getTitleFormatter(),
1126            $services->getLinkCache(),
1127            $services->getSpecialPageFactory(),
1128            $services->getHookContainer()
1129        );
1130    },
1131
1132    'LinksMigration' => static function ( MediaWikiServices $services ): LinksMigration {
1133        return new LinksMigration(
1134            $services->getMainConfig(),
1135            $services->getLinkTargetLookup()
1136        );
1137    },
1138
1139    'LinkTargetLookup' => static function ( MediaWikiServices $services ): LinkTargetLookup {
1140        return new LinkTargetStore(
1141            $services->getConnectionProvider(),
1142            $services->getLocalServerObjectCache(),
1143            $services->getMainWANObjectCache()
1144        );
1145    },
1146
1147    'LocalisationCache' => static function ( MediaWikiServices $services ): LocalisationCache {
1148        $conf = $services->getMainConfig()->get( MainConfigNames::LocalisationCacheConf );
1149
1150        $logger = LoggerFactory::getInstance( 'localisation' );
1151
1152        $store = LocalisationCache::getStoreFromConf(
1153            $conf, $services->getMainConfig()->get( MainConfigNames::CacheDirectory ) );
1154        $logger->debug( 'LocalisationCache using store ' . get_class( $store ) );
1155
1156        return new $conf['class'](
1157            new ServiceOptions(
1158                LocalisationCache::CONSTRUCTOR_OPTIONS,
1159                // Two of the options are stored in $wgLocalisationCacheConf
1160                $conf,
1161                // In case someone set that config variable and didn't reset all keys, set defaults.
1162                [
1163                    'forceRecache' => false,
1164                    'manualRecache' => false,
1165                ],
1166                // Some other options come from config itself
1167                $services->getMainConfig()
1168            ),
1169            $store,
1170            $logger,
1171            [ static function () use ( $services ) {
1172                // NOTE: Make sure we use the same cache object that is assigned in the
1173                // constructor of the MessageBlobStore class used by ResourceLoader.
1174                // T231866: Avoid circular dependency via ResourceLoader.
1175                MessageBlobStore::clearGlobalCacheEntry( $services->getMainWANObjectCache() );
1176            } ],
1177            $services->getLanguageNameUtils(),
1178            $services->getHookContainer()
1179        );
1180    },
1181
1182    'LocalServerObjectCache' => static function ( MediaWikiServices $services ): BagOStuff {
1183        return $services->getObjectCacheFactory()->getInstance( CACHE_ACCEL );
1184    },
1185
1186    'LockManagerGroupFactory' => static function ( MediaWikiServices $services ): LockManagerGroupFactory {
1187        return new LockManagerGroupFactory(
1188            WikiMap::getCurrentWikiDbDomain()->getId(),
1189            $services->getMainConfig()->get( MainConfigNames::LockManagers )
1190        );
1191    },
1192
1193    'MagicWordFactory' => static function ( MediaWikiServices $services ): MagicWordFactory {
1194        return new MagicWordFactory(
1195            $services->getContentLanguage(),
1196            $services->getHookContainer()
1197        );
1198    },
1199
1200    'MainConfig' => static function ( MediaWikiServices $services ): Config {
1201        // Use the 'main' config from the ConfigFactory service.
1202        return $services->getConfigFactory()->makeConfig( 'main' );
1203    },
1204
1205    'MainObjectStash' => static function ( MediaWikiServices $services ): BagOStuff {
1206        $mainConfig = $services->getMainConfig();
1207
1208        $id = $mainConfig->get( MainConfigNames::MainStash );
1209        $store = $services->getObjectCacheFactory()->getInstance( $id );
1210        $store->getLogger()->debug( 'MainObjectStash using store {class}', [
1211            'class' => get_class( $store )
1212        ] );
1213
1214        return $store;
1215    },
1216
1217    'MainWANObjectCache' => static function ( MediaWikiServices $services ): WANObjectCache {
1218        $mainConfig = $services->getMainConfig();
1219
1220        $store = $services->get( '_LocalClusterCache' );
1221        $logger = $store->getLogger();
1222        $logger->debug( 'MainWANObjectCache using store {class}', [
1223            'class' => get_class( $store )
1224        ] );
1225
1226        $wanParams = $mainConfig->get( MainConfigNames::WANObjectCache ) + [
1227            'cache' => $store,
1228            'logger' => $logger,
1229            'secret' => $mainConfig->get( MainConfigNames::SecretKey ),
1230        ];
1231        if ( MW_ENTRY_POINT !== 'cli' ) {
1232            // Send the statsd data post-send on HTTP requests; avoid in CLI mode (T181385)
1233            $wanParams['stats'] = $services->getStatsdDataFactory();
1234            // Let pre-emptive refreshes happen post-send on HTTP requests
1235            $wanParams['asyncHandler'] = [ DeferredUpdates::class, 'addCallableUpdate' ];
1236        }
1237        return new WANObjectCache( $wanParams );
1238    },
1239
1240    'MediaHandlerFactory' => static function ( MediaWikiServices $services ): MediaHandlerFactory {
1241        return new MediaHandlerFactory(
1242            LoggerFactory::getInstance( 'MediaHandlerFactory' ),
1243            $services->getMainConfig()->get( MainConfigNames::MediaHandlers )
1244        );
1245    },
1246
1247    'MergeHistoryFactory' => static function ( MediaWikiServices $services ): MergeHistoryFactory {
1248        return $services->getService( '_PageCommandFactory' );
1249    },
1250
1251    'MessageCache' => static function ( MediaWikiServices $services ): MessageCache {
1252        $mainConfig = $services->getMainConfig();
1253        $clusterCache = ObjectCache::getInstance( $mainConfig->get( MainConfigNames::MessageCacheType ) );
1254        $srvCache = $mainConfig->get( MainConfigNames::UseLocalMessageCache )
1255            ? $services->getLocalServerObjectCache()
1256            : new EmptyBagOStuff();
1257
1258        $logger = LoggerFactory::getInstance( 'MessageCache' );
1259        $logger->debug( 'MessageCache using store {class}', [
1260            'class' => get_class( $clusterCache )
1261        ] );
1262
1263        $options = new ServiceOptions( MessageCache::CONSTRUCTOR_OPTIONS, $mainConfig );
1264
1265        return new MessageCache(
1266            $services->getMainWANObjectCache(),
1267            $clusterCache,
1268            $srvCache,
1269            $services->getContentLanguage(),
1270            $services->getLanguageConverterFactory(),
1271            $logger,
1272            $options,
1273            $services->getLanguageFactory(),
1274            $services->getLocalisationCache(),
1275            $services->getLanguageNameUtils(),
1276            $services->getLanguageFallback(),
1277            $services->getHookContainer(),
1278            $services->getParserFactory()
1279        );
1280    },
1281
1282    'MessageFormatterFactory' => static function ( MediaWikiServices $services ): IMessageFormatterFactory {
1283        return new MessageFormatterFactory();
1284    },
1285
1286    'MicroStash' => static function ( MediaWikiServices $services ): BagOStuff {
1287        $mainConfig = $services->getMainConfig();
1288
1289        $id = $mainConfig->get( MainConfigNames::MicroStashType );
1290        $store = $services->getObjectCacheFactory()->getInstance( $id );
1291
1292        $store->getLogger()->debug( 'MicroStash using store {class}', [
1293            'class' => get_class( $store )
1294        ] );
1295
1296        return $store;
1297    },
1298
1299    'MimeAnalyzer' => static function ( MediaWikiServices $services ): MimeAnalyzer {
1300        $logger = LoggerFactory::getInstance( 'Mime' );
1301        $mainConfig = $services->getMainConfig();
1302        $hookRunner = new HookRunner( $services->getHookContainer() );
1303        $params = [
1304            'typeFile' => $mainConfig->get( MainConfigNames::MimeTypeFile ),
1305            'infoFile' => $mainConfig->get( MainConfigNames::MimeInfoFile ),
1306            'xmlTypes' => $mainConfig->get( MainConfigNames::XMLMimeTypes ),
1307            'guessCallback' => static function (
1308                $mimeAnalyzer, &$head, &$tail, $file, &$mime
1309            ) use ( $logger, $hookRunner ) {
1310                // Also test DjVu
1311                $deja = new DjVuImage( $file );
1312                if ( $deja->isValid() ) {
1313                    $logger->info( "Detected $file as image/vnd.djvu\n" );
1314                    $mime = 'image/vnd.djvu';
1315
1316                    return;
1317                }
1318                // Some strings by reference for performance - assuming well-behaved hooks
1319                $hookRunner->onMimeMagicGuessFromContent(
1320                    $mimeAnalyzer, $head, $tail, $file, $mime );
1321            },
1322            'extCallback' => static function ( $mimeAnalyzer, $ext, &$mime ) use ( $hookRunner ) {
1323                // Media handling extensions can improve the MIME detected
1324                $hookRunner->onMimeMagicImproveFromExtension( $mimeAnalyzer, $ext, $mime );
1325            },
1326            'initCallback' => static function ( $mimeAnalyzer ) use ( $hookRunner ) {
1327                // Allow media handling extensions adding MIME-types and MIME-info
1328                $hookRunner->onMimeMagicInit( $mimeAnalyzer );
1329            },
1330            'logger' => $logger
1331        ];
1332
1333        if ( $params['infoFile'] === 'includes/mime.info' ) {
1334            $params['infoFile'] = MimeAnalyzer::USE_INTERNAL;
1335        }
1336
1337        if ( $params['typeFile'] === 'includes/mime.types' ) {
1338            $params['typeFile'] = MimeAnalyzer::USE_INTERNAL;
1339        }
1340
1341        $detectorCmd = $mainConfig->get( MainConfigNames::MimeDetectorCommand );
1342        if ( $detectorCmd ) {
1343            $factory = $services->getShellCommandFactory();
1344            $params['detectCallback'] = static function ( $file ) use ( $detectorCmd, $factory ) {
1345                $result = $factory->create()
1346                    // $wgMimeDetectorCommand can contain commands with parameters
1347                    ->unsafeParams( $detectorCmd )
1348                    ->params( $file )
1349                    ->execute();
1350                return $result->getStdout();
1351            };
1352        }
1353
1354        return new MimeAnalyzer( $params );
1355    },
1356
1357    'MovePageFactory' => static function ( MediaWikiServices $services ): MovePageFactory {
1358        return $services->getService( '_PageCommandFactory' );
1359    },
1360
1361    'NamespaceInfo' => static function ( MediaWikiServices $services ): NamespaceInfo {
1362        return new NamespaceInfo(
1363            new ServiceOptions( NamespaceInfo::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1364            $services->getHookContainer(),
1365            ExtensionRegistry::getInstance()->getAttribute( 'ExtensionNamespaces' ),
1366            ExtensionRegistry::getInstance()->getAttribute( 'ImmovableNamespaces' )
1367        );
1368    },
1369
1370    'NameTableStoreFactory' => static function ( MediaWikiServices $services ): NameTableStoreFactory {
1371        return new NameTableStoreFactory(
1372            $services->getDBLoadBalancerFactory(),
1373            $services->getMainWANObjectCache(),
1374            LoggerFactory::getInstance( 'NameTableSqlStore' )
1375        );
1376    },
1377
1378    'ObjectCacheFactory' => static function ( MediaWikiServices $services ): ObjectCacheFactory {
1379        return new ObjectCacheFactory(
1380            new ServiceOptions(
1381                ObjectCacheFactory::CONSTRUCTOR_OPTIONS,
1382                $services->getMainConfig()
1383            ),
1384            $services->getStatsFactory(),
1385            LoggerFactory::getProvider(),
1386            WikiMap::getCurrentWikiDbDomain()->getId()
1387        );
1388    },
1389
1390    'ObjectFactory' => static function ( MediaWikiServices $services ): ObjectFactory {
1391        return new ObjectFactory( $services );
1392    },
1393
1394    'OldRevisionImporter' => static function ( MediaWikiServices $services ): OldRevisionImporter {
1395        return new ImportableOldRevisionImporter(
1396            true,
1397            LoggerFactory::getInstance( 'OldRevisionImporter' ),
1398            $services->getConnectionProvider(),
1399            $services->getRevisionStoreFactory()->getRevisionStoreForImport(),
1400            $services->getSlotRoleRegistry(),
1401            $services->getWikiPageFactory(),
1402            $services->getPageUpdaterFactory(),
1403            $services->getUserFactory()
1404        );
1405    },
1406
1407    'PageEditStash' => static function ( MediaWikiServices $services ): PageEditStash {
1408        return new PageEditStash(
1409            ObjectCache::getLocalClusterInstance(),
1410            $services->getConnectionProvider(),
1411            LoggerFactory::getInstance( 'StashEdit' ),
1412            $services->getStatsdDataFactory(),
1413            $services->getUserEditTracker(),
1414            $services->getUserFactory(),
1415            $services->getWikiPageFactory(),
1416            $services->getHookContainer(),
1417            defined( 'MEDIAWIKI_JOB_RUNNER' ) || MW_ENTRY_POINT === 'cli'
1418                ? PageEditStash::INITIATOR_JOB_OR_CLI
1419                : PageEditStash::INITIATOR_USER
1420        );
1421    },
1422
1423    'PageProps' => static function ( MediaWikiServices $services ): PageProps {
1424        return new PageProps(
1425            $services->getLinkBatchFactory(),
1426            $services->getConnectionProvider()
1427        );
1428    },
1429
1430    'PageRestHelperFactory' => static function ( MediaWikiServices $services ): PageRestHelperFactory {
1431        return new PageRestHelperFactory(
1432            new ServiceOptions( PageRestHelperFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1433            $services->getRevisionLookup(),
1434            $services->getTitleFormatter(),
1435            $services->getPageStore(),
1436            $services->getParsoidOutputStash(),
1437            $services->getStatsdDataFactory(),
1438            $services->getParsoidOutputAccess(),
1439            $services->getHtmlTransformFactory(),
1440            $services->getContentHandlerFactory(),
1441            $services->getLanguageFactory(),
1442            $services->getRedirectStore(),
1443            $services->getLanguageConverterFactory()
1444        );
1445    },
1446
1447    'PageStore' => static function ( MediaWikiServices $services ): PageStore {
1448        return $services->getPageStoreFactory()->getPageStore();
1449    },
1450
1451    'PageStoreFactory' => static function ( MediaWikiServices $services ): PageStoreFactory {
1452        $options = new ServiceOptions(
1453            PageStoreFactory::CONSTRUCTOR_OPTIONS,
1454            $services->getMainConfig()
1455        );
1456
1457        return new PageStoreFactory(
1458            $options,
1459            $services->getDBLoadBalancerFactory(),
1460            $services->getNamespaceInfo(),
1461            $services->getTitleParser(),
1462            $services->getLinkCache(),
1463            $services->getStatsdDataFactory()
1464        );
1465    },
1466
1467    'PageUpdaterFactory' => static function (
1468        MediaWikiServices $services
1469    ): PageUpdaterFactory {
1470        $editResultCache = new EditResultCache(
1471            $services->getMainObjectStash(),
1472            $services->getConnectionProvider(),
1473            new ServiceOptions(
1474                EditResultCache::CONSTRUCTOR_OPTIONS,
1475                $services->getMainConfig()
1476            )
1477        );
1478
1479        return new PageUpdaterFactory(
1480            $services->getRevisionStore(),
1481            $services->getRevisionRenderer(),
1482            $services->getSlotRoleRegistry(),
1483            $services->getParserCache(),
1484            $services->getJobQueueGroup(),
1485            $services->getMessageCache(),
1486            $services->getContentLanguage(),
1487            $services->getDBLoadBalancerFactory(),
1488            $services->getContentHandlerFactory(),
1489            $services->getHookContainer(),
1490            $editResultCache,
1491            $services->getUserNameUtils(),
1492            LoggerFactory::getInstance( 'SavePage' ),
1493            new ServiceOptions(
1494                PageUpdaterFactory::CONSTRUCTOR_OPTIONS,
1495                $services->getMainConfig()
1496            ),
1497            $services->getUserEditTracker(),
1498            $services->getUserGroupManager(),
1499            $services->getTitleFormatter(),
1500            $services->getContentTransformer(),
1501            $services->getPageEditStash(),
1502            $services->getTalkPageNotificationManager(),
1503            $services->getMainWANObjectCache(),
1504            $services->getPermissionManager(),
1505            $services->getWikiPageFactory(),
1506            $services->getChangeTagsStore()->getSoftwareTags()
1507        );
1508    },
1509
1510    'Parser' => static function ( MediaWikiServices $services ): Parser {
1511        // This service exists as convenience function to get the global parser in global code.
1512        // Do not use this service for dependency injection or in service wiring (T343070).
1513        // Use the 'ParserFactory' service instead.
1514        return $services->getParserFactory()->getMainInstance();
1515    },
1516
1517    'ParserCache' => static function ( MediaWikiServices $services ): ParserCache {
1518        return $services->getParserCacheFactory()
1519            ->getParserCache( ParserCacheFactory::DEFAULT_NAME );
1520    },
1521
1522    'ParserCacheFactory' => static function ( MediaWikiServices $services ): ParserCacheFactory {
1523        $config = $services->getMainConfig();
1524        $cache = ObjectCache::getInstance( $config->get( MainConfigNames::ParserCacheType ) );
1525        $wanCache = $services->getMainWANObjectCache();
1526
1527        $options = new ServiceOptions( ParserCacheFactory::CONSTRUCTOR_OPTIONS, $config );
1528
1529        return new ParserCacheFactory(
1530            $cache,
1531            $wanCache,
1532            $services->getHookContainer(),
1533            $services->getJsonCodec(),
1534            $services->getStatsFactory(),
1535            LoggerFactory::getInstance( 'ParserCache' ),
1536            $options,
1537            $services->getTitleFactory(),
1538            $services->getWikiPageFactory(),
1539            $services->getGlobalIdGenerator()
1540        );
1541    },
1542
1543    'ParserFactory' => static function ( MediaWikiServices $services ): ParserFactory {
1544        $options = new ServiceOptions( Parser::CONSTRUCTOR_OPTIONS,
1545            $services->getMainConfig()
1546        );
1547
1548        return new ParserFactory(
1549            $options,
1550            $services->getMagicWordFactory(),
1551            $services->getContentLanguage(),
1552            $services->getUrlUtils(),
1553            $services->getSpecialPageFactory(),
1554            $services->getLinkRendererFactory(),
1555            $services->getNamespaceInfo(),
1556            LoggerFactory::getInstance( 'Parser' ),
1557            $services->getBadFileLookup(),
1558            $services->getLanguageConverterFactory(),
1559            $services->getHookContainer(),
1560            $services->getTidy(),
1561            $services->getMainWANObjectCache(),
1562            $services->getUserOptionsLookup(),
1563            $services->getUserFactory(),
1564            $services->getTitleFormatter(),
1565            $services->getHttpRequestFactory(),
1566            $services->getTrackingCategories(),
1567            $services->getSignatureValidatorFactory(),
1568            $services->getUserNameUtils()
1569        );
1570    },
1571
1572    'ParserOutputAccess' => static function ( MediaWikiServices $services ): ParserOutputAccess {
1573        return new ParserOutputAccess(
1574            $services->getParserCacheFactory(),
1575            $services->getRevisionLookup(),
1576            $services->getRevisionRenderer(),
1577            $services->getStatsdDataFactory(),
1578            $services->getDBLoadBalancerFactory(),
1579            $services->getChronologyProtector(),
1580            LoggerFactory::getProvider(),
1581            $services->getWikiPageFactory(),
1582            $services->getTitleFormatter()
1583        );
1584    },
1585
1586    'ParsoidDataAccess' => static function ( MediaWikiServices $services ): DataAccess {
1587        $mainConfig = $services->getMainConfig();
1588        return new MWDataAccess(
1589            new ServiceOptions( MWDataAccess::CONSTRUCTOR_OPTIONS, $mainConfig ),
1590            $services->getRepoGroup(),
1591            $services->getBadFileLookup(),
1592            $services->getHookContainer(),
1593            $services->getContentTransformer(),
1594            $services->getReadOnlyMode(),
1595            $services->getParserFactory(), // *legacy* parser factory
1596            $services->getLinkBatchFactory()
1597        );
1598    },
1599
1600    'ParsoidOutputAccess' => static function ( MediaWikiServices $services ): ParsoidOutputAccess {
1601        return new ParsoidOutputAccess(
1602            $services->getParsoidParserFactory(),
1603            $services->getParserOutputAccess(),
1604            $services->getPageStore(),
1605            $services->getRevisionLookup(),
1606            $services->getParsoidSiteConfig(),
1607            $services->getContentHandlerFactory()
1608        );
1609    },
1610
1611    'ParsoidOutputStash' => static function ( MediaWikiServices $services ): ParsoidOutputStash {
1612        // TODO: Determine storage requirements and config options for stashing parsoid
1613        //       output for VE edits (T309016).
1614        $config = $services->getMainConfig()->get( MainConfigNames::ParsoidCacheConfig );
1615        $backend = $config['StashType']
1616            ? ObjectCache::getInstance( $config['StashType'] )
1617            : $services->getMainObjectStash();
1618
1619        return new SimpleParsoidOutputStash(
1620            $services->getContentHandlerFactory(),
1621            $backend,
1622            $config['StashDuration']
1623        );
1624    },
1625
1626    'ParsoidPageConfigFactory' => static function ( MediaWikiServices $services ): MWPageConfigFactory {
1627        return new MWPageConfigFactory(
1628            $services->getRevisionStore(),
1629            $services->getSlotRoleRegistry(),
1630            $services->getLanguageFactory()
1631        );
1632    },
1633
1634    'ParsoidParserFactory' => static function ( MediaWikiServices $services ): ParsoidParserFactory {
1635        return new ParsoidParserFactory(
1636            $services->getParsoidSiteConfig(),
1637            $services->getParsoidDataAccess(),
1638            $services->getParsoidPageConfigFactory(),
1639            $services->getLanguageConverterFactory(),
1640            $services->getParserFactory(),
1641            $services->getGlobalIdGenerator()
1642        );
1643    },
1644
1645    'ParsoidSiteConfig' => static function ( MediaWikiServices $services ): SiteConfig {
1646        $mainConfig = $services->getMainConfig();
1647        $parsoidSettings = $mainConfig->get( MainConfigNames::ParsoidSettings );
1648        return new MWSiteConfig(
1649            new ServiceOptions( MWSiteConfig::CONSTRUCTOR_OPTIONS, $mainConfig ),
1650            $parsoidSettings,
1651            $services->getObjectFactory(),
1652            $services->getContentLanguage(),
1653            $services->getStatsdDataFactory(),
1654            $services->getMagicWordFactory(),
1655            $services->getNamespaceInfo(),
1656            $services->getSpecialPageFactory(),
1657            $services->getInterwikiLookup(),
1658            $services->getUserOptionsLookup(),
1659            $services->getLanguageFactory(),
1660            $services->getLanguageConverterFactory(),
1661            $services->getLanguageNameUtils(),
1662            $services->getUrlUtils(),
1663            ExtensionRegistry::getInstance()->getAttribute( 'ParsoidModules' ),
1664            // These arguments are temporary and will be removed once
1665            // better solutions are found.
1666            $services->getParserFactory(), // T268776
1667            $mainConfig, // T268777
1668            ExtensionRegistry::getInstance()->isLoaded( 'TimedMediaHandler' )
1669        );
1670    },
1671
1672    'PasswordFactory' => static function ( MediaWikiServices $services ): PasswordFactory {
1673        $config = $services->getMainConfig();
1674        return new PasswordFactory(
1675            $config->get( MainConfigNames::PasswordConfig ),
1676            $config->get( MainConfigNames::PasswordDefault )
1677        );
1678    },
1679
1680    'PasswordReset' => static function ( MediaWikiServices $services ): PasswordReset {
1681        $options = new ServiceOptions( PasswordReset::CONSTRUCTOR_OPTIONS, $services->getMainConfig() );
1682        return new PasswordReset(
1683            $options,
1684            LoggerFactory::getInstance( 'authentication' ),
1685            $services->getAuthManager(),
1686            $services->getHookContainer(),
1687            $services->getConnectionProvider(),
1688            $services->getUserFactory(),
1689            $services->getUserNameUtils(),
1690            $services->getUserOptionsLookup()
1691        );
1692    },
1693
1694    'PerDbNameStatsdDataFactory' => static function ( MediaWikiServices $services ): StatsdDataFactoryInterface {
1695        $config = $services->getMainConfig();
1696        $wiki = $config->get( MainConfigNames::DBname );
1697        return new PrefixingStatsdDataFactoryProxy(
1698            $services->getStatsdDataFactory(),
1699            $wiki
1700        );
1701    },
1702
1703    'PermissionManager' => static function ( MediaWikiServices $services ): PermissionManager {
1704        return new PermissionManager(
1705            new ServiceOptions(
1706                PermissionManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
1707            ),
1708            $services->getSpecialPageFactory(),
1709            $services->getNamespaceInfo(),
1710            $services->getGroupPermissionsLookup(),
1711            $services->getUserGroupManager(),
1712            $services->getBlockManager(),
1713            $services->getFormatterFactory()->getBlockErrorFormatter(
1714                new LazyLocalizationContext( static function () {
1715                    return RequestContext::getMain();
1716                } )
1717            ),
1718            $services->getHookContainer(),
1719            $services->getUserCache(),
1720            $services->getRedirectLookup(),
1721            $services->getRestrictionStore(),
1722            $services->getTitleFormatter(),
1723            $services->getTempUserConfig(),
1724            $services->getUserFactory(),
1725            $services->getActionFactory()
1726        );
1727    },
1728
1729    'Pingback' => static function ( MediaWikiServices $services ): Pingback {
1730        return new Pingback(
1731            $services->getMainConfig(),
1732            $services->getConnectionProvider(),
1733            ObjectCache::getLocalClusterInstance(),
1734            $services->getHttpRequestFactory(),
1735            LoggerFactory::getInstance( 'Pingback' )
1736        );
1737    },
1738
1739    'PoolCounterFactory' => static function ( MediaWikiServices $services ): PoolCounterFactory {
1740        $mainConfig = $services->getMainConfig();
1741        return new PoolCounterFactory(
1742            $mainConfig->get( MainConfigNames::PoolCounterConf ),
1743            $mainConfig->get( MainConfigNames::PoolCountClientConf ),
1744            LoggerFactory::getInstance( 'poolcounter' )
1745        );
1746    },
1747
1748    'PreferencesFactory' => static function ( MediaWikiServices $services ): PreferencesFactory {
1749        $factory = new DefaultPreferencesFactory(
1750            new ServiceOptions(
1751                DefaultPreferencesFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1752            $services->getContentLanguage(),
1753            $services->getAuthManager(),
1754            $services->getLinkRendererFactory()->create(),
1755            $services->getNamespaceInfo(),
1756            $services->getPermissionManager(),
1757            $services->getLanguageConverterFactory()->getLanguageConverter(),
1758            $services->getLanguageNameUtils(),
1759            $services->getHookContainer(),
1760            $services->getUserOptionsManager(),
1761            $services->getLanguageConverterFactory(),
1762            $services->getParserFactory(),
1763            $services->getSkinFactory(),
1764            $services->getUserGroupManager(),
1765            $services->getSignatureValidatorFactory()
1766        );
1767        $factory->setLogger( LoggerFactory::getInstance( 'preferences' ) );
1768
1769        return $factory;
1770    },
1771
1772    'PreloadedContentBuilder' => static function ( MediaWikiServices $services ): PreloadedContentBuilder {
1773        return new PreloadedContentBuilder(
1774            $services->getContentHandlerFactory(),
1775            $services->getWikiPageFactory(),
1776            $services->getRedirectLookup(),
1777            $services->getSpecialPageFactory(),
1778            $services->getContentTransformer(),
1779            $services->getHookContainer(),
1780        );
1781    },
1782
1783    'ProxyLookup' => static function ( MediaWikiServices $services ): ProxyLookup {
1784        $mainConfig = $services->getMainConfig();
1785        return new ProxyLookup(
1786            $mainConfig->get( MainConfigNames::CdnServers ),
1787            $mainConfig->get( MainConfigNames::CdnServersNoPurge ),
1788            $services->getHookContainer()
1789        );
1790    },
1791
1792    'RateLimiter' => static function ( MediaWikiServices $services ): RateLimiter {
1793        $rateLimiter = new RateLimiter(
1794            new ServiceOptions( RateLimiter::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
1795            $services->getWRStatsFactory(),
1796            $services->getCentralIdLookupFactory()->getNonLocalLookup(),
1797            $services->getUserFactory(),
1798            $services->getUserGroupManager(),
1799            $services->getHookContainer()
1800        );
1801
1802        $rateLimiter->setStats( $services->getStatsdDataFactory() );
1803
1804        return $rateLimiter;
1805    },
1806
1807    'ReadOnlyMode' => static function ( MediaWikiServices $services ): ReadOnlyMode {
1808        return new ReadOnlyMode(
1809            new ConfiguredReadOnlyMode(
1810                $services->getMainConfig()->get( MainConfigNames::ReadOnly ),
1811                $services->getMainConfig()->get( MainConfigNames::ReadOnlyFile )
1812            ),
1813            $services->getDBLoadBalancerFactory()
1814        );
1815    },
1816
1817    'RedirectLookup' => static function ( MediaWikiServices $services ): RedirectLookup {
1818        return $services->getRedirectStore();
1819    },
1820
1821    'RedirectStore' => static function ( MediaWikiServices $services ): RedirectStore {
1822        return new RedirectStore( $services->getWikiPageFactory() );
1823    },
1824
1825    'RepoGroup' => static function ( MediaWikiServices $services ): RepoGroup {
1826        $config = $services->getMainConfig();
1827        return new RepoGroup(
1828            $config->get( MainConfigNames::LocalFileRepo ),
1829            $config->get( MainConfigNames::ForeignFileRepos ),
1830            $services->getMainWANObjectCache(),
1831            $services->getMimeAnalyzer()
1832        );
1833    },
1834
1835    'ResourceLoader' => static function ( MediaWikiServices $services ): ResourceLoader {
1836        $config = $services->getMainConfig();
1837
1838        $maxage = $config->get( MainConfigNames::ResourceLoaderMaxage );
1839        $rl = new ResourceLoader(
1840            $config,
1841            LoggerFactory::getInstance( 'resourceloader' ),
1842            $config->get( MainConfigNames::ResourceLoaderUseObjectCacheForDeps )
1843                ? new KeyValueDependencyStore( $services->getMainObjectStash() )
1844                : new SqlModuleDependencyStore( $services->getDBLoadBalancer() ),
1845            [
1846                'loadScript' => $config->get( MainConfigNames::LoadScript ),
1847                'maxageVersioned' => $maxage['versioned'] ?? null,
1848                'maxageUnversioned' => $maxage['unversioned'] ?? null,
1849            ]
1850        );
1851
1852        $extRegistry = ExtensionRegistry::getInstance();
1853        // Attribute has precedence over config
1854        $modules = $extRegistry->getAttribute( 'ResourceModules' )
1855            + $config->get( MainConfigNames::ResourceModules );
1856        $moduleSkinStyles = $extRegistry->getAttribute( 'ResourceModuleSkinStyles' )
1857            + $config->get( MainConfigNames::ResourceModuleSkinStyles );
1858
1859        $rl->setModuleSkinStyles( $moduleSkinStyles );
1860        $rl->addSource( $config->get( MainConfigNames::ResourceLoaderSources ) );
1861
1862        // Core modules, then extension/skin modules
1863        $rl->register( include MW_INSTALL_PATH . '/resources/Resources.php' );
1864        $rl->register( $modules );
1865        $hookRunner = new \MediaWiki\ResourceLoader\HookRunner( $services->getHookContainer() );
1866        $hookRunner->onResourceLoaderRegisterModules( $rl );
1867
1868        $msgPosterAttrib = $extRegistry->getAttribute( 'MessagePosterModule' );
1869        $rl->register( 'mediawiki.messagePoster', [
1870            'localBasePath' => MW_INSTALL_PATH,
1871            'debugRaw' => false,
1872            'scripts' => array_merge(
1873                [
1874                    "resources/src/mediawiki.messagePoster/factory.js",
1875                    "resources/src/mediawiki.messagePoster/MessagePoster.js",
1876                    "resources/src/mediawiki.messagePoster/WikitextMessagePoster.js",
1877                ],
1878                $msgPosterAttrib['scripts'] ?? []
1879            ),
1880            'dependencies' => array_merge(
1881                [
1882                    'oojs',
1883                    'mediawiki.api',
1884                    'mediawiki.ForeignApi',
1885                ],
1886                $msgPosterAttrib['dependencies'] ?? []
1887            ),
1888        ] );
1889
1890        if ( $config->get( MainConfigNames::EnableJavaScriptTest ) === true ) {
1891            $rl->registerTestModules();
1892        }
1893
1894        return $rl;
1895    },
1896
1897    'RestrictionStore' => static function ( MediaWikiServices $services ): RestrictionStore {
1898        return new RestrictionStore(
1899            new ServiceOptions(
1900                RestrictionStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
1901            ),
1902            $services->getMainWANObjectCache(),
1903            $services->getDBLoadBalancer(),
1904            $services->getLinkCache(),
1905            $services->getLinksMigration(),
1906            $services->getCommentStore(),
1907            $services->getHookContainer(),
1908            $services->getPageStore()
1909        );
1910    },
1911
1912    'RevertedTagUpdateManager' => static function ( MediaWikiServices $services ): RevertedTagUpdateManager {
1913        $editResultCache = new EditResultCache(
1914            $services->getMainObjectStash(),
1915            $services->getConnectionProvider(),
1916            new ServiceOptions(
1917                EditResultCache::CONSTRUCTOR_OPTIONS,
1918                $services->getMainConfig()
1919            )
1920        );
1921
1922        return new RevertedTagUpdateManager(
1923            $editResultCache,
1924            $services->getJobQueueGroup()
1925        );
1926    },
1927
1928    'RevisionFactory' => static function ( MediaWikiServices $services ): RevisionFactory {
1929        return $services->getRevisionStore();
1930    },
1931
1932    'RevisionLookup' => static function ( MediaWikiServices $services ): RevisionLookup {
1933        return $services->getRevisionStore();
1934    },
1935
1936    'RevisionRenderer' => static function ( MediaWikiServices $services ): RevisionRenderer {
1937        $renderer = new RevisionRenderer(
1938            $services->getDBLoadBalancer(),
1939            $services->getSlotRoleRegistry(),
1940            $services->getContentRenderer()
1941        );
1942
1943        $renderer->setLogger( LoggerFactory::getInstance( 'SaveParse' ) );
1944        return $renderer;
1945    },
1946
1947    'RevisionStore' => static function ( MediaWikiServices $services ): RevisionStore {
1948        return $services->getRevisionStoreFactory()->getRevisionStore();
1949    },
1950
1951    'RevisionStoreFactory' => static function ( MediaWikiServices $services ): RevisionStoreFactory {
1952        return new RevisionStoreFactory(
1953            $services->getDBLoadBalancerFactory(),
1954            $services->getBlobStoreFactory(),
1955            $services->getNameTableStoreFactory(),
1956            $services->getSlotRoleRegistry(),
1957            $services->getMainWANObjectCache(),
1958            $services->getLocalServerObjectCache(),
1959            $services->getCommentStore(),
1960            $services->getActorStoreFactory(),
1961            LoggerFactory::getInstance( 'RevisionStore' ),
1962            $services->getContentHandlerFactory(),
1963            $services->getPageStoreFactory(),
1964            $services->getTitleFactory(),
1965            $services->getHookContainer()
1966        );
1967    },
1968
1969    'RollbackPageFactory' => static function ( MediaWikiServices $services ): RollbackPageFactory {
1970        return $services->get( '_PageCommandFactory' );
1971    },
1972
1973    'RowCommentFormatter' => static function ( MediaWikiServices $services ): RowCommentFormatter {
1974        return new RowCommentFormatter(
1975            $services->getCommentParserFactory(),
1976            $services->getCommentStore()
1977        );
1978    },
1979
1980    'SearchEngineConfig' => static function ( MediaWikiServices $services ): SearchEngineConfig {
1981        // @todo This should not take a Config object, but it's not so easy to remove because it
1982        // exposes it in a getter, which is actually used.
1983        return new SearchEngineConfig(
1984            $services->getMainConfig(),
1985            $services->getContentLanguage(),
1986            $services->getHookContainer(),
1987            ExtensionRegistry::getInstance()->getAttribute( 'SearchMappings' ),
1988            $services->getUserOptionsLookup()
1989        );
1990    },
1991
1992    'SearchEngineFactory' => static function ( MediaWikiServices $services ): SearchEngineFactory {
1993        return new SearchEngineFactory(
1994            $services->getSearchEngineConfig(),
1995            $services->getHookContainer(),
1996            $services->getConnectionProvider()
1997        );
1998    },
1999
2000    'SearchResultThumbnailProvider' => static function ( MediaWikiServices $services ): SearchResultThumbnailProvider {
2001        return new SearchResultThumbnailProvider(
2002            $services->getRepoGroup(),
2003            $services->getHookContainer()
2004        );
2005    },
2006
2007    'ShellboxClientFactory' => static function ( MediaWikiServices $services ): ShellboxClientFactory {
2008        $urls = $services->getMainConfig()->get( MainConfigNames::ShellboxUrls );
2009
2010        return new ShellboxClientFactory(
2011            $services->getHttpRequestFactory(),
2012            $urls,
2013            $services->getMainConfig()->get( MainConfigNames::ShellboxSecretKey )
2014        );
2015    },
2016
2017    'ShellCommandFactory' => static function ( MediaWikiServices $services ): CommandFactory {
2018        $config = $services->getMainConfig();
2019
2020        $limits = [
2021            'time' => $config->get( MainConfigNames::MaxShellTime ),
2022            'walltime' => $config->get( MainConfigNames::MaxShellWallClockTime ),
2023            'memory' => $config->get( MainConfigNames::MaxShellMemory ),
2024            'filesize' => $config->get( MainConfigNames::MaxShellFileSize ),
2025        ];
2026        $cgroup = $config->get( MainConfigNames::ShellCgroup );
2027        $restrictionMethod = $config->get( MainConfigNames::ShellRestrictionMethod );
2028
2029        $factory = new CommandFactory( $services->getShellboxClientFactory(),
2030            $limits, $cgroup, $restrictionMethod );
2031        $factory->setLogger( LoggerFactory::getInstance( 'exec' ) );
2032        $factory->logStderr();
2033
2034        return $factory;
2035    },
2036
2037    'SignatureValidatorFactory' => static function ( MediaWikiServices $services ): SignatureValidatorFactory {
2038        return new SignatureValidatorFactory(
2039            new ServiceOptions(
2040                SignatureValidator::CONSTRUCTOR_OPTIONS,
2041                $services->getMainConfig()
2042            ),
2043            // Use closures for these to avoid a circular dependency on Parser
2044            static function () use ( $services ) {
2045                return $services->getParserFactory();
2046            },
2047            static function () use ( $services ) {
2048                return $services->get( '_Parsoid' );
2049            },
2050            $services->getParsoidPageConfigFactory(),
2051            $services->getSpecialPageFactory(),
2052            $services->getTitleFactory()
2053        );
2054    },
2055
2056    'SiteLookup' => static function ( MediaWikiServices $services ): SiteLookup {
2057        // Use SiteStore as the SiteLookup as well. This was originally separated
2058        // to allow for a cacheable read-only interface, but this was never used.
2059        // SiteStore has caching (see below).
2060        return $services->getSiteStore();
2061    },
2062
2063    'SiteStore' => static function ( MediaWikiServices $services ): SiteStore {
2064        $rawSiteStore = new DBSiteStore( $services->getConnectionProvider() );
2065
2066        $cache = $services->getLocalServerObjectCache();
2067        if ( $cache instanceof EmptyBagOStuff ) {
2068            $cache = ObjectCache::getLocalClusterInstance();
2069        }
2070
2071        return new CachingSiteStore( $rawSiteStore, $cache );
2072    },
2073
2074    /** @suppress PhanTypeInvalidCallableArrayKey */
2075    'SkinFactory' => static function ( MediaWikiServices $services ): SkinFactory {
2076        $factory = new SkinFactory(
2077            $services->getObjectFactory(),
2078            (array)$services->getMainConfig()->get( MainConfigNames::SkipSkins )
2079        );
2080
2081        $names = $services->getMainConfig()->get( MainConfigNames::ValidSkinNames );
2082
2083        foreach ( $names as $name => $skin ) {
2084            if ( is_array( $skin ) ) {
2085                $spec = $skin;
2086                $displayName = $skin['displayname'] ?? $name;
2087                $skippable = $skin['skippable'] ?? null;
2088            } else {
2089                $displayName = $skin;
2090                $skippable = null;
2091                $spec = [
2092                    'name' => $name,
2093                    'class' => "Skin$skin"
2094                ];
2095            }
2096            $factory->register( $name, $displayName, $spec, $skippable );
2097        }
2098
2099        // Register a hidden "fallback" skin
2100        $factory->register( 'fallback', 'Fallback', [
2101            'class' => SkinFallback::class,
2102            'args' => [
2103                [
2104                    'name' => 'fallback',
2105                    'styles' => [ 'mediawiki.skinning.interface' ],
2106                    'templateDirectory' => __DIR__ . '/skins/templates/fallback',
2107                ]
2108            ]
2109        ], true );
2110        // Register a hidden skin for api output
2111        $factory->register( 'apioutput', 'ApiOutput', [
2112            'class' => SkinApi::class,
2113            'args' => [
2114                [
2115                    'name' => 'apioutput',
2116                    'styles' => [ 'mediawiki.skinning.interface' ],
2117                    'templateDirectory' => __DIR__ . '/skins/templates/apioutput',
2118                ]
2119            ]
2120        ], true );
2121
2122        return $factory;
2123    },
2124
2125    'SlotRoleRegistry' => static function ( MediaWikiServices $services ): SlotRoleRegistry {
2126        $registry = new SlotRoleRegistry(
2127            $services->getSlotRoleStore()
2128        );
2129
2130        $config = $services->getMainConfig();
2131        $contentHandlerFactory = $services->getContentHandlerFactory();
2132        $hookContainer = $services->getHookContainer();
2133        $titleFactory = $services->getTitleFactory();
2134        $registry->defineRole(
2135            SlotRecord::MAIN,
2136            static function () use ( $config, $contentHandlerFactory, $hookContainer, $titleFactory ) {
2137                return new MainSlotRoleHandler(
2138                    $config->get( MainConfigNames::NamespaceContentModels ),
2139                    $contentHandlerFactory,
2140                    $hookContainer,
2141                    $titleFactory
2142                );
2143            }
2144        );
2145
2146        return $registry;
2147    },
2148
2149    'SlotRoleStore' => static function ( MediaWikiServices $services ): NameTableStore {
2150        return $services->getNameTableStoreFactory()->getSlotRoles();
2151    },
2152
2153    'SpamChecker' => static function ( MediaWikiServices $services ): SpamChecker {
2154        return new SpamChecker(
2155            (array)$services->getMainConfig()->get( MainConfigNames::SpamRegex ),
2156            (array)$services->getMainConfig()->get( MainConfigNames::SummarySpamRegex )
2157        );
2158    },
2159
2160    'SpecialPageFactory' => static function ( MediaWikiServices $services ): SpecialPageFactory {
2161        return new SpecialPageFactory(
2162            new ServiceOptions(
2163                SpecialPageFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
2164            $services->getContentLanguage(),
2165            $services->getObjectFactory(),
2166            $services->getTitleFactory(),
2167            $services->getHookContainer()
2168        );
2169    },
2170
2171    'StatsdDataFactory' => static function ( MediaWikiServices $services ): IBufferingStatsdDataFactory {
2172        return new BufferingStatsdDataFactory(
2173            rtrim( $services->getMainConfig()->get( MainConfigNames::StatsdMetricPrefix ), '.' )
2174        );
2175    },
2176
2177    'StatsFactory' => static function ( MediaWikiServices $services ): StatsFactory {
2178        $config = $services->getMainConfig();
2179        $format = \Wikimedia\Stats\OutputFormats::getFormatFromString(
2180            $config->get( MainConfigNames::StatsFormat ) ?? 'null'
2181        );
2182        $cache = new StatsCache;
2183        $emitter = \Wikimedia\Stats\OutputFormats::getNewEmitter(
2184            $config->get( MainConfigNames::StatsPrefix ) ?? 'MediaWiki',
2185            $cache,
2186            \Wikimedia\Stats\OutputFormats::getNewFormatter( $format ),
2187            $config->get( MainConfigNames::StatsTarget )
2188        );
2189        $factory = new StatsFactory( $cache, $emitter, LoggerFactory::getInstance( 'Stats' ) );
2190        return $factory->withStatsdDataFactory( $services->getStatsdDataFactory() );
2191    },
2192
2193    'TalkPageNotificationManager' => static function (
2194        MediaWikiServices $services
2195    ): TalkPageNotificationManager {
2196        return new TalkPageNotificationManager(
2197            new ServiceOptions(
2198                TalkPageNotificationManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
2199            ),
2200            $services->getConnectionProvider(),
2201            $services->getReadOnlyMode(),
2202            $services->getRevisionLookup(),
2203            $services->getHookContainer(),
2204            $services->getUserFactory()
2205        );
2206    },
2207
2208    'TempFSFileFactory' => static function ( MediaWikiServices $services ): TempFSFileFactory {
2209        return new TempFSFileFactory( $services->getMainConfig()->get( MainConfigNames::TmpDirectory ) );
2210    },
2211
2212    'TempUserConfig' => static function ( MediaWikiServices $services ): RealTempUserConfig {
2213        return new RealTempUserConfig(
2214            $services->getMainConfig()->get( MainConfigNames::AutoCreateTempUser )
2215        );
2216    },
2217
2218    'TempUserCreator' => static function ( MediaWikiServices $services ): TempUserCreator {
2219        return new TempUserCreator(
2220            $services->getTempUserConfig(),
2221            $services->getObjectFactory(),
2222            $services->getUserFactory(),
2223            $services->getAuthManager(),
2224            $services->getCentralIdLookup(),
2225            // This is supposed to match ThrottlePreAuthenticationProvider
2226            new Throttler(
2227                $services->getMainConfig()->get( MainConfigNames::TempAccountCreationThrottle ),
2228                [
2229                    'type' => 'tempacctcreate',
2230                    'cache' => ObjectCache::getLocalClusterInstance(),
2231                ]
2232            )
2233        );
2234    },
2235
2236    'Tidy' => static function ( MediaWikiServices $services ): TidyDriverBase {
2237        return new RemexDriver(
2238            new ServiceOptions(
2239                RemexDriver::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
2240            )
2241        );
2242    },
2243
2244    'TitleFactory' => static function ( MediaWikiServices $services ): TitleFactory {
2245        return new TitleFactory();
2246    },
2247
2248    'TitleFormatter' => static function ( MediaWikiServices $services ): TitleFormatter {
2249        return $services->getService( '_MediaWikiTitleCodec' );
2250    },
2251
2252    'TitleMatcher' => static function ( MediaWikiServices $services ): TitleMatcher {
2253        return new TitleMatcher(
2254            new ServiceOptions(
2255                TitleMatcher::CONSTRUCTOR_OPTIONS,
2256                $services->getMainConfig()
2257            ),
2258            $services->getContentLanguage(),
2259            $services->getLanguageConverterFactory(),
2260            $services->getHookContainer(),
2261            $services->getWikiPageFactory(),
2262            $services->getUserNameUtils(),
2263            $services->getRepoGroup(),
2264            $services->getTitleFactory()
2265        );
2266    },
2267
2268    'TitleParser' => static function ( MediaWikiServices $services ): TitleParser {
2269        return $services->getService( '_MediaWikiTitleCodec' );
2270    },
2271
2272    'TrackingCategories' => static function ( MediaWikiServices $services ): TrackingCategories {
2273        return new TrackingCategories(
2274            new ServiceOptions(
2275                TrackingCategories::CONSTRUCTOR_OPTIONS,
2276                $services->getMainConfig()
2277            ),
2278            $services->getNamespaceInfo(),
2279            $services->getTitleParser(),
2280            LoggerFactory::getInstance( 'TrackingCategories' )
2281        );
2282    },
2283
2284    'UnblockUserFactory' => static function ( MediaWikiServices $services ): UnblockUserFactory {
2285        return $services->getService( '_UserBlockCommandFactory' );
2286    },
2287
2288    'UndeletePageFactory' => static function ( MediaWikiServices $services ): UndeletePageFactory {
2289        return $services->getService( '_PageCommandFactory' );
2290    },
2291
2292    'UploadRevisionImporter' => static function ( MediaWikiServices $services ): UploadRevisionImporter {
2293        return new ImportableUploadRevisionImporter(
2294            $services->getMainConfig()->get( MainConfigNames::EnableUploads ),
2295            LoggerFactory::getInstance( 'UploadRevisionImporter' )
2296        );
2297    },
2298
2299    'UrlUtils' => static function ( MediaWikiServices $services ): UrlUtils {
2300        $config = $services->getMainConfig();
2301        return new UrlUtils( [
2302            UrlUtils::SERVER => $config->get( MainConfigNames::Server ),
2303            UrlUtils::CANONICAL_SERVER => $config->get( MainConfigNames::CanonicalServer ),
2304            UrlUtils::INTERNAL_SERVER => $config->get( MainConfigNames::InternalServer ),
2305            UrlUtils::FALLBACK_PROTOCOL => RequestContext::getMain()->getRequest()->getProtocol(),
2306            UrlUtils::HTTPS_PORT => $config->get( MainConfigNames::HttpsPort ),
2307            UrlUtils::VALID_PROTOCOLS => $config->get( MainConfigNames::UrlProtocols ),
2308        ] );
2309    },
2310
2311    'UserCache' => static function ( MediaWikiServices $services ): UserCache {
2312        return new UserCache(
2313            LoggerFactory::getInstance( 'UserCache' ),
2314            $services->getConnectionProvider(),
2315            $services->getLinkBatchFactory()
2316        );
2317    },
2318
2319    'UserEditTracker' => static function ( MediaWikiServices $services ): UserEditTracker {
2320        return new UserEditTracker(
2321            $services->getActorMigration(),
2322            $services->getConnectionProvider(),
2323            $services->getJobQueueGroup()
2324        );
2325    },
2326
2327    'UserFactory' => static function ( MediaWikiServices $services ): UserFactory {
2328        return new UserFactory(
2329            new ServiceOptions(
2330                UserFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
2331            ),
2332            $services->getDBLoadBalancerFactory(),
2333            $services->getUserNameUtils()
2334        );
2335    },
2336
2337    'UserGroupManager' => static function ( MediaWikiServices $services ): UserGroupManager {
2338        return $services->getUserGroupManagerFactory()->getUserGroupManager();
2339    },
2340
2341    'UserGroupManagerFactory' => static function ( MediaWikiServices $services ): UserGroupManagerFactory {
2342        return new UserGroupManagerFactory(
2343            new ServiceOptions(
2344                UserGroupManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
2345            ),
2346            $services->getReadOnlyMode(),
2347            $services->getDBLoadBalancerFactory(),
2348            $services->getHookContainer(),
2349            $services->getUserEditTracker(),
2350            $services->getGroupPermissionsLookup(),
2351            $services->getJobQueueGroupFactory(),
2352            LoggerFactory::getInstance( 'UserGroupManager' ),
2353            $services->getTempUserConfig(),
2354            [ static function ( UserIdentity $user ) use ( $services ) {
2355                if ( $user->getWikiId() === UserIdentity::LOCAL ) {
2356                    $services->getPermissionManager()->invalidateUsersRightsCache( $user );
2357                }
2358                $services->getUserFactory()->invalidateCache( $user );
2359            } ]
2360        );
2361    },
2362
2363    'UserIdentityLookup' => static function ( MediaWikiServices $services ): UserIdentityLookup {
2364        return $services->getActorStoreFactory()->getUserIdentityLookup();
2365    },
2366
2367    'UserIdentityUtils' => static function ( MediaWikiServices $services ): UserIdentityUtils {
2368        return new UserIdentityUtils(
2369            $services->getTempUserConfig()
2370        );
2371    },
2372
2373    'UserNamePrefixSearch' => static function ( MediaWikiServices $services ): UserNamePrefixSearch {
2374        return new UserNamePrefixSearch(
2375            $services->getConnectionProvider(),
2376            $services->getUserNameUtils(),
2377            $services->getHideUserUtils()
2378        );
2379    },
2380
2381    'UserNameUtils' => static function ( MediaWikiServices $services ): UserNameUtils {
2382        $messageFormatterFactory = new MessageFormatterFactory( Message::FORMAT_PLAIN );
2383        return new UserNameUtils(
2384            new ServiceOptions(
2385                UserNameUtils::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
2386            ),
2387            $services->getContentLanguage(),
2388            LoggerFactory::getInstance( 'UserNameUtils' ),
2389            $services->getTitleParser(),
2390            $messageFormatterFactory->getTextFormatter(
2391                $services->getContentLanguage()->getCode()
2392            ),
2393            $services->getHookContainer(),
2394            $services->getTempUserConfig()
2395        );
2396    },
2397
2398    'UserOptionsLookup' => static function ( MediaWikiServices $services ): UserOptionsLookup {
2399        return $services->getUserOptionsManager();
2400    },
2401
2402    'UserOptionsManager' => static function ( MediaWikiServices $services ): UserOptionsManager {
2403        return new UserOptionsManager(
2404            new ServiceOptions( UserOptionsManager::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
2405            $services->get( '_DefaultOptionsLookup' ),
2406            $services->getLanguageConverterFactory(),
2407            $services->getConnectionProvider(),
2408            LoggerFactory::getInstance( 'UserOptionsManager' ),
2409            $services->getHookContainer(),
2410            $services->getUserFactory(),
2411            $services->getUserNameUtils()
2412        );
2413    },
2414
2415    'UserRegistrationLookup' => static function ( MediaWikiServices $services ): UserRegistrationLookup {
2416        $lookup = new UserRegistrationLookup(
2417            new ServiceOptions( UserRegistrationLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
2418            $services->getObjectFactory()
2419        );
2420        if ( !$lookup->isRegistered( LocalUserRegistrationProvider::TYPE ) ) {
2421            throw new ConfigException( 'UserRegistrationLookup: Local provider is required' );
2422        }
2423        return $lookup;
2424    },
2425
2426    'WatchedItemQueryService' => static function ( MediaWikiServices $services ): WatchedItemQueryService {
2427        return new WatchedItemQueryService(
2428            $services->getConnectionProvider(),
2429            $services->getCommentStore(),
2430            $services->getWatchedItemStore(),
2431            $services->getHookContainer(),
2432            $services->getUserOptionsLookup(),
2433            $services->getTempUserConfig(),
2434            $services->getMainConfig()->get( MainConfigNames::WatchlistExpiry ),
2435            $services->getMainConfig()->get( MainConfigNames::MaxExecutionTimeForExpensiveQueries )
2436        );
2437    },
2438
2439    'WatchedItemStore' => static function ( MediaWikiServices $services ): WatchedItemStore {
2440        $store = new WatchedItemStore(
2441            new ServiceOptions( WatchedItemStore::CONSTRUCTOR_OPTIONS,
2442                $services->getMainConfig() ),
2443            $services->getDBLoadBalancerFactory(),
2444            $services->getJobQueueGroup(),
2445            $services->getMainObjectStash(),
2446            new HashBagOStuff( [ 'maxKeys' => 100 ] ),
2447            $services->getReadOnlyMode(),
2448            $services->getNamespaceInfo(),
2449            $services->getRevisionLookup(),
2450            $services->getLinkBatchFactory()
2451        );
2452        $store->setStatsdDataFactory( $services->getStatsdDataFactory() );
2453
2454        if ( $services->getMainConfig()->get( MainConfigNames::ReadOnlyWatchedItemStore ) ) {
2455            $store = new NoWriteWatchedItemStore( $store );
2456        }
2457
2458        return $store;
2459    },
2460
2461    'WatchlistManager' => static function ( MediaWikiServices $services ): WatchlistManager {
2462        return new WatchlistManager(
2463            [
2464                WatchlistManager::OPTION_ENOTIF =>
2465                    RecentChange::isEnotifEnabled( $services->getMainConfig() ),
2466            ],
2467            $services->getHookContainer(),
2468            $services->getReadOnlyMode(),
2469            $services->getRevisionLookup(),
2470            $services->getTalkPageNotificationManager(),
2471            $services->getWatchedItemStore(),
2472            $services->getUserFactory(),
2473            $services->getNamespaceInfo(),
2474            $services->getWikiPageFactory()
2475        );
2476    },
2477
2478    'WikiExporterFactory' => static function ( MediaWikiServices $services ): WikiExporterFactory {
2479        return new WikiExporterFactory(
2480            $services->getHookContainer(),
2481            $services->getRevisionStore(),
2482            $services->getTitleParser(),
2483            $services->getCommentStore()
2484        );
2485    },
2486
2487    'WikiImporterFactory' => static function ( MediaWikiServices $services ): WikiImporterFactory {
2488        return new WikiImporterFactory(
2489            $services->getMainConfig(),
2490            $services->getHookContainer(),
2491            $services->getContentLanguage(),
2492            $services->getNamespaceInfo(),
2493            $services->getTitleFactory(),
2494            $services->getWikiPageFactory(),
2495            $services->getWikiRevisionUploadImporter(),
2496            $services->getContentHandlerFactory(),
2497            $services->getSlotRoleRegistry()
2498        );
2499    },
2500
2501    'WikiPageFactory' => static function ( MediaWikiServices $services ): WikiPageFactory {
2502        return new WikiPageFactory(
2503            $services->getTitleFactory(),
2504            new HookRunner( $services->getHookContainer() ),
2505            $services->getDBLoadBalancerFactory()
2506        );
2507    },
2508
2509    'WikiRevisionOldRevisionImporterNoUpdates' => static function (
2510        MediaWikiServices $services
2511    ): ImportableOldRevisionImporter {
2512        return new ImportableOldRevisionImporter(
2513            false,
2514            LoggerFactory::getInstance( 'OldRevisionImporter' ),
2515            $services->getConnectionProvider(),
2516            $services->getRevisionStoreFactory()->getRevisionStoreForImport(),
2517            $services->getSlotRoleRegistry(),
2518            $services->getWikiPageFactory(),
2519            $services->getPageUpdaterFactory(),
2520            $services->getUserFactory()
2521        );
2522    },
2523
2524    'WRStatsFactory' => static function ( MediaWikiServices $services ): WRStatsFactory {
2525        return new WRStatsFactory(
2526            new BagOStuffStatsStore( $services->getMicroStash() )
2527        );
2528    },
2529
2530    '_ConditionalDefaultsLookup' => static function (
2531        MediaWikiServices $services
2532    ): ConditionalDefaultsLookup {
2533        return new ConditionalDefaultsLookup(
2534            new ServiceOptions(
2535                ConditionalDefaultsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig()
2536            ),
2537            $services->getUserRegistrationLookup()
2538        );
2539    },
2540
2541    '_DefaultOptionsLookup' => static function ( MediaWikiServices $services ): DefaultOptionsLookup {
2542        return new DefaultOptionsLookup(
2543            new ServiceOptions( DefaultOptionsLookup::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
2544            $services->getContentLanguage(),
2545            $services->getHookContainer(),
2546            $services->getNamespaceInfo(),
2547            $services->get( '_ConditionalDefaultsLookup' )
2548        );
2549    },
2550
2551    '_EditConstraintFactory' => static function ( MediaWikiServices $services ): EditConstraintFactory {
2552        // This service is internal and currently only exists because a significant number
2553        // of dependencies will be needed by different constraints. It is not part of
2554        // the public interface and has no corresponding method in MediaWikiServices
2555        return new EditConstraintFactory(
2556            // Multiple
2557            new ServiceOptions(
2558                EditConstraintFactory::CONSTRUCTOR_OPTIONS,
2559                $services->getMainConfig()
2560            ),
2561            LoggerFactory::getProvider(),
2562
2563            // UserBlockConstraint
2564            $services->getPermissionManager(),
2565
2566            // EditFilterMergedContentHookConstraint
2567            $services->getHookContainer(),
2568
2569            // ReadOnlyConstraint
2570            $services->getReadOnlyMode(),
2571
2572            // SpamRegexConstraint
2573            $services->getSpamChecker(),
2574
2575            // UserRateLimitConstraint
2576            $services->getRateLimiter()
2577        );
2578    },
2579
2580    '_LocalClusterCache' => static function ( MediaWikiServices $services ): BagOStuff {
2581        $mainConfig = $services->getMainConfig();
2582        $id = $mainConfig->get( MainConfigNames::MainCacheType );
2583        return $services->getObjectCacheFactory()->getInstance( $id );
2584    },
2585
2586    '_MediaWikiTitleCodec' => static function ( MediaWikiServices $services ): MediaWikiTitleCodec {
2587        return new MediaWikiTitleCodec(
2588            $services->getContentLanguage(),
2589            $services->getGenderCache(),
2590            $services->getMainConfig()->get( MainConfigNames::LocalInterwikis ),
2591            $services->getInterwikiLookup(),
2592            $services->getNamespaceInfo()
2593        );
2594    },
2595
2596    '_PageCommandFactory' => static function ( MediaWikiServices $services ): PageCommandFactory {
2597        return new PageCommandFactory(
2598            $services->getMainConfig(),
2599            $services->getDBLoadBalancerFactory(),
2600            $services->getNamespaceInfo(),
2601            $services->getWatchedItemStore(),
2602            $services->getRepoGroup(),
2603            $services->getReadOnlyMode(),
2604            $services->getContentHandlerFactory(),
2605            $services->getRevisionStore(),
2606            $services->getSpamChecker(),
2607            $services->getTitleFormatter(),
2608            $services->getHookContainer(),
2609            $services->getWikiPageFactory(),
2610            $services->getUserFactory(),
2611            $services->getActorMigration(),
2612            $services->getActorNormalization(),
2613            $services->getTitleFactory(),
2614            $services->getUserEditTracker(),
2615            $services->getCollationFactory(),
2616            $services->getJobQueueGroup(),
2617            $services->getCommentStore(),
2618            $services->getMainObjectStash(),
2619            WikiMap::getCurrentWikiDbDomain()->getId(),
2620            WebRequest::getRequestId(),
2621            $services->getBacklinkCacheFactory(),
2622            LoggerFactory::getInstance( 'UndeletePage' ),
2623            $services->getPageUpdaterFactory(),
2624            $services->getMessageFormatterFactory()->getTextFormatter(
2625                $services->getContentLanguage()->getCode()
2626            ),
2627            $services->getArchivedRevisionLookup(),
2628            $services->getRestrictionStore(),
2629            $services->getLinkTargetLookup()
2630        );
2631    },
2632
2633    '_ParserObserver' => static function ( MediaWikiServices $services ): ParserObserver {
2634        return new ParserObserver( LoggerFactory::getInstance( 'DuplicateParse' ) );
2635    },
2636
2637    '_Parsoid' => static function ( MediaWikiServices $services ): Parsoid {
2638        return new Parsoid(
2639            $services->getParsoidSiteConfig(),
2640            $services->getParsoidDataAccess()
2641        );
2642    },
2643
2644    '_SettingsBuilder' => static function ( MediaWikiServices $services ): SettingsBuilder {
2645        return SettingsBuilder::getInstance();
2646    },
2647
2648    '_SqlBlobStore' => static function ( MediaWikiServices $services ): SqlBlobStore {
2649        return $services->getBlobStoreFactory()->newSqlBlobStore();
2650    },
2651
2652    '_UserBlockCommandFactory' => static function ( MediaWikiServices $services ): UserBlockCommandFactory {
2653        return new UserBlockCommandFactory(
2654            new ServiceOptions( UserBlockCommandFactory::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
2655            $services->getHookContainer(),
2656            $services->getBlockPermissionCheckerFactory(),
2657            $services->getBlockUtils(),
2658            $services->getDatabaseBlockStore(),
2659            $services->getBlockRestrictionStore(),
2660            $services->getUserFactory(),
2661            $services->getUserEditTracker(),
2662            LoggerFactory::getInstance( 'BlockManager' ),
2663            $services->getTitleFactory(),
2664            $services->getBlockActionInfo()
2665        );
2666    },
2667
2668    ///////////////////////////////////////////////////////////////////////////
2669    // NOTE: When adding a service here, don't forget to add a getter function
2670    // in the MediaWikiServices class. The convenience getter should just call
2671    // $this->getService( 'FooBarService' ).
2672    ///////////////////////////////////////////////////////////////////////////
2673
2674];