rebuildLocalisationCache.php

Go to the documentation of this file.

<?php
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
 
require_once __DIR__ . '/Maintenance.php';
 
class RebuildLocalisationCache extends Maintenance {
    public function __construct() {
        parent::__construct();
        $this->addDescription( 'Rebuild the localisation cache' );
        $this->addOption( 'force', 'Rebuild all files, even ones not out of date' );
        $this->addOption( 'threads', 'Fork more than one thread', false, true );
        $this->addOption( 'outdir', 'Override the output directory (normally $wgCacheDirectory)',
            false, true );
        $this->addOption( 'lang', 'Only rebuild these languages, comma separated.',
            false, true );
        $this->addOption(
            'store-class',
            'Override the LC store class (normally $wgLocalisationCacheConf[\'storeClass\'])',
            false,
            true
        );
    }
 
    public function finalSetup() {
        # This script needs to be run to build the inital l10n cache. But if
        # $wgLanguageCode is not 'en', it won't be able to run because there is
        # no l10n cache. Break the cycle by forcing $wgLanguageCode = 'en'.
        global $wgLanguageCode;
        $wgLanguageCode = 'en';
        parent::finalSetup();
    }
 
    public function execute() {
        global $wgLocalisationCacheConf, $wgCacheDirectory;
 
        $force = $this->hasOption( 'force' );
        $threads = $this->getOption( 'threads', 1 );
        if ( $threads < 1 || $threads != intval( $threads ) ) {
            $this->output( "Invalid thread count specified; running single-threaded.\n" );
            $threads = 1;
        }
        if ( $threads > 1 && wfIsWindows() ) {
            $this->output( "Threaded rebuild is not supported on Windows; running single-threaded.\n" );
            $threads = 1;
        }
        if ( $threads > 1 && !function_exists( 'pcntl_fork' ) ) {
            $this->output( "PHP pcntl extension is not present; running single-threaded.\n" );
            $threads = 1;
        }
 
        $conf = $wgLocalisationCacheConf;
        // Allow fallbacks to create CDB files
        $conf['manualRecache'] = false;
        $conf['forceRecache'] = $force || !empty( $conf['forceRecache'] );
        if ( $this->hasOption( 'outdir' ) ) {
            $conf['storeDirectory'] = $this->getOption( 'outdir' );
        }
 
        if ( $this->hasOption( 'store-class' ) ) {
            $conf['storeClass'] = $this->getOption( 'store-class' );
        }
        // XXX Copy-pasted from ServiceWiring.php. Do we need a factory for this one caller?
        $services = MediaWikiServices::getInstance();
        $lc = new LocalisationCacheBulkLoad(
            new ServiceOptions(
                LocalisationCache::CONSTRUCTOR_OPTIONS,
                $conf,
                $services->getMainConfig()
            ),
            LocalisationCache::getStoreFromConf( $conf, $wgCacheDirectory ),
            LoggerFactory::getInstance( 'localisation' ),
            [ function () use ( $services ) {
                MessageBlobStore::clearGlobalCacheEntry( $services->getMainWANObjectCache() );
            } ],
            $services->getLanguageNameUtils(),
            $services->getHookContainer()
        );
 
        $allCodes = array_keys( $services
            ->getLanguageNameUtils()
            ->getLanguageNames( null, 'mwfile' ) );
        if ( $this->hasOption( 'lang' ) ) {
            # Validate requested languages
            $codes = array_intersect( $allCodes,
                explode( ',', $this->getOption( 'lang' ) ) );
            # Bailed out if nothing is left
            if ( count( $codes ) == 0 ) {
                $this->fatalError( 'None of the languages specified exists.' );
            }
        } else {
            # By default get all languages
            $codes = $allCodes;
        }
        sort( $codes );
 
        // Initialise and split into chunks
        $numRebuilt = 0;
        $total = count( $codes );
        $chunks = array_chunk( $codes, ceil( count( $codes ) / $threads ) );
        $pids = [];
        $parentStatus = 0;
        foreach ( $chunks as $codes ) {
            // Do not fork for only one thread
            $pid = ( $threads > 1 ) ? pcntl_fork() : -1;
 
            if ( $pid === 0 ) {
                // Child, reseed because there is no bug in PHP:
                // https://bugs.php.net/bug.php?id=42465
                mt_srand( getmypid() );
 
                $this->doRebuild( $codes, $lc, $force );
                exit( 0 );
            } elseif ( $pid === -1 ) {
                // Fork failed or one thread, do it serialized
                $numRebuilt += $this->doRebuild( $codes, $lc, $force );
            } else {
                // Main thread
                $pids[] = $pid;
            }
        }
        // Wait for all children
        foreach ( $pids as $pid ) {
            $status = 0;
            pcntl_waitpid( $pid, $status );
            if ( pcntl_wexitstatus( $status ) ) {
                // Pass a fatal error code through to the caller
                $parentStatus = pcntl_wexitstatus( $status );
            }
        }
 
        if ( !$pids ) {
            $this->output( "$numRebuilt languages rebuilt out of $total\n" );
            if ( $numRebuilt === 0 ) {
                $this->output( "Use --force to rebuild the caches which are still fresh.\n" );
            }
        }
        if ( $parentStatus ) {
            exit( $parentStatus );
        }
    }
 
    private function doRebuild( $codes, $lc, $force ) {
        $numRebuilt = 0;
        foreach ( $codes as $code ) {
            if ( $force || $lc->isExpired( $code ) ) {
                $this->output( "Rebuilding $code...\n" );
                $lc->recache( $code );
                $numRebuilt++;
            }
        }
 
        return $numRebuilt;
    }
 
    public function setForce( $forced = true ) {
        $this->mOptions['force'] = $forced;
    }
}
 
$maintClass = RebuildLocalisationCache::class;
require_once RUN_MAINTENANCE_IF_MAIN;