ClassicInterwikiLookup.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Interwiki;
 
use Interwiki;
use MapCacheLRU;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Language\Language;
use MediaWiki\Languages\LanguageNameUtils;
use MediaWiki\MainConfigNames;
use MediaWiki\WikiMap\WikiMap;
use Wikimedia\ObjectCache\WANObjectCache;
use Wikimedia\Rdbms\IConnectionProvider;
 
class ClassicInterwikiLookup implements InterwikiLookup {
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::InterwikiExpiry,
        MainConfigNames::InterwikiCache,
        MainConfigNames::InterwikiScopes,
        MainConfigNames::InterwikiFallbackSite,
        MainConfigNames::InterwikiMagic,
        MainConfigNames::VirtualDomainsMapping,
        'wikiId',
    ];
 
    private ServiceOptions $options;
    private Language $contLang;
    private WANObjectCache $wanCache;
    private HookRunner $hookRunner;
    private IConnectionProvider $dbProvider;
    private LanguageNameUtils $languageNameUtils;
 
    private MapCacheLRU $instances;
    private int $interwikiScopes;
    private ?array $data;
    private string $wikiId;
    private ?string $thisSite = null;
    private array $virtualDomainsMapping;
 
    public function __construct(
        ServiceOptions $options,
        Language $contLang,
        WANObjectCache $wanCache,
        HookContainer $hookContainer,
        IConnectionProvider $dbProvider,
        LanguageNameUtils $languageNameUtils
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->options = $options;
 
        $this->contLang = $contLang;
        $this->wanCache = $wanCache;
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->dbProvider = $dbProvider;
        $this->languageNameUtils = $languageNameUtils;
 
        $this->instances = new MapCacheLRU( 1000 );
        $this->interwikiScopes = $options->get( MainConfigNames::InterwikiScopes );
 
        $interwikiData = $options->get( MainConfigNames::InterwikiCache );
        $this->data = is_array( $interwikiData ) ? $interwikiData : null;
        $this->wikiId = $options->get( 'wikiId' );
        $this->virtualDomainsMapping = $options->get( MainConfigNames::VirtualDomainsMapping ) ?? [];
    }
 
    public function isValidInterwiki( $prefix ) {
        $iw = $this->fetch( $prefix );
        return (bool)$iw;
    }
 
    public function fetch( $prefix ) {
        if ( $prefix === null || $prefix === '' ) {
            return null;
        }
 
        $prefix = $this->contLang->lc( $prefix );
 
        return $this->instances->getWithSetCallback(
            $prefix,
            function () use ( $prefix ) {
                return $this->load( $prefix );
            }
        );
    }
 
    public function invalidateCache( $prefix ) {
        $this->instances->clear( $prefix );
 
        $key = $this->wanCache->makeKey( 'interwiki', $prefix );
        $this->wanCache->delete( $key );
    }
 
    private function getPregenValue( string $prefix ) {
        // Lazily resolve site name
        if ( $this->interwikiScopes >= 3 && !$this->thisSite ) {
            $this->thisSite = $this->data['__sites:' . $this->wikiId]
                ?? $this->options->get( MainConfigNames::InterwikiFallbackSite );
        }
 
        $value = $this->data[$this->wikiId . ':' . $prefix] ?? false;
        // Site level
        if ( $value === false && $this->interwikiScopes >= 3 ) {
            $value = $this->data["_{$this->thisSite}:{$prefix}"] ?? false;
        }
        // Global level
        if ( $value === false && $this->interwikiScopes >= 2 ) {
            $value = $this->data["__global:{$prefix}"] ?? false;
        }
 
        return $value;
    }
 
    private function load( $prefix ) {
        if ( $this->data !== null ) {
            $value = $this->getPregenValue( $prefix );
            return $value ? $this->makeFromPregen( $prefix, $value ) : false;
        }
 
        $iwData = [];
        $abort = !$this->hookRunner->onInterwikiLoadPrefix( $prefix, $iwData );
        if ( isset( $iwData['iw_url'] ) ) {
            // Hook provided data
            return $this->makeFromRow( $iwData );
        }
        if ( $abort ) {
            // Hook indicated no other source may be considered
            return false;
        }
 
        $iwData = $this->wanCache->getWithSetCallback(
            $this->wanCache->makeKey( 'interwiki', $prefix ),
            $this->options->get( MainConfigNames::InterwikiExpiry ),
            function ( $oldValue, &$ttl, array &$setOpts ) use ( $prefix ) {
                // Global interlanguage link
                if ( $this->options->get( MainConfigNames::InterwikiMagic )
                    && $this->languageNameUtils->getLanguageName( $prefix )
                ) {
                    $row = $this->loadFromDB( $prefix, 'virtual-interwiki-interlanguage' );
                } else {
                    // Local interwiki link
                    $row = $this->loadFromDB( $prefix );
 
                    // Global interwiki link (not interlanguage)
                    if ( !$row && isset( $this->virtualDomainsMapping['virtual-interwiki'] ) ) {
                        $row = $this->loadFromDB( $prefix, 'virtual-interwiki' );
                    }
                }
 
                return $row ? (array)$row : '!NONEXISTENT';
            }
        );
 
        // Handle non-existent case
        return is_array( $iwData ) ? $this->makeFromRow( $iwData ) : false;
    }
 
    /*
     * Fetch interwiki data from a DB query.
     *
     * @param string $prefix The interwiki prefix
     * @param string|false $domain Domain ID, or false for the current domain
     * @return stdClass|false interwiki data
     */
    private function loadFromDB( $prefix, $domain = false ) {
        $dbr = $this->dbProvider->getReplicaDatabase( $domain );
        $row = $dbr->newSelectQueryBuilder()
            ->select( self::selectFields() )
            ->from( 'interwiki' )
            ->where( [ 'iw_prefix' => $prefix ] )
            ->caller( __METHOD__ )->fetchRow();
 
        return $row;
    }
 
    private function makeFromRow( array $row ) {
        $url = $row['iw_url'];
        $local = $row['iw_local'] ?? 0;
        $trans = $row['iw_trans'] ?? 0;
        $api = $row['iw_api'] ?? '';
        $wikiId = $row['iw_wikiid'] ?? '';
 
        return new Interwiki( null, $url, $api, $wikiId, $local, $trans );
    }
 
    private function makeFromPregen( string $prefix, string $value ) {
        // Split values
        [ $local, $url ] = explode( ' ', $value, 2 );
        return new Interwiki( $prefix, $url, '', '', (int)$local );
    }
 
    private function getAllPrefixesPregenerated( $local ) {
        // Lazily resolve site name
        if ( $this->interwikiScopes >= 3 && !$this->thisSite ) {
            $this->thisSite = $this->data['__sites:' . $this->wikiId]
                ?? $this->options->get( MainConfigNames::InterwikiFallbackSite );
        }
 
        // List of interwiki sources
        $sources = [];
        // Global level
        if ( $this->interwikiScopes >= 2 ) {
            $sources[] = '__global';
        }
        // Site level
        if ( $this->interwikiScopes >= 3 ) {
            $sources[] = '_' . $this->thisSite;
        }
        $sources[] = $this->wikiId;
 
        $data = [];
        foreach ( $sources as $source ) {
            $list = $this->data['__list:' . $source] ?? '';
            foreach ( explode( ' ', $list ) as $iw_prefix ) {
                $row = $this->data["{$source}:{$iw_prefix}"] ?? null;
                if ( !$row ) {
                    continue;
                }
 
                [ $iw_local, $iw_url ] = explode( ' ', $row );
 
                if ( $local !== null && $local != $iw_local ) {
                    continue;
                }
 
                $data[$iw_prefix] = [
                    'iw_prefix' => $iw_prefix,
                    'iw_url' => $iw_url,
                    'iw_local' => $iw_local,
                ];
            }
        }
 
        return array_values( $data );
    }
 
    public static function buildCdbHash(
        array $allPrefixes, int $scope = 1, ?string $thisSite = null
    ): array {
        $result = [];
        $wikiId = WikiMap::getCurrentWikiId();
        $keyPrefix = ( $scope >= 2 ) ? '__global' : $wikiId;
        if ( $scope >= 3 && $thisSite ) {
            $result[ "__sites:$wikiId" ] = $thisSite;
            $keyPrefix = "_$thisSite";
        }
        $list = [];
        foreach ( $allPrefixes as $iwInfo ) {
            $prefix = $iwInfo['iw_prefix'];
            $result["$keyPrefix:$prefix"] = implode( ' ', [
                $iwInfo['iw_local'] ?? 0, $iwInfo['iw_url']
            ] );
            $list[] = $prefix;
        }
        $result["__list:$keyPrefix"]  = implode( ' ', $list );
        $result["__list:__sites"] = $wikiId;
        return $result;
    }
 
    private function getAllPrefixesDB( $local ) {
        $where = [];
        if ( $local !== null ) {
            $where['iw_local'] = (int)$local;
        }
 
        $dbr = $this->dbProvider->getReplicaDatabase();
        $res = $dbr->newSelectQueryBuilder()
            ->select( self::selectFields() )
            ->from( 'interwiki' )
            ->where( $where )
            ->orderBy( 'iw_prefix' )
            ->caller( __METHOD__ )->fetchResultSet();
 
        $retval = [];
        foreach ( $res as $row ) {
            $retval[] = (array)$row;
        }
        return $retval;
    }
 
    public function getAllPrefixes( $local = null ) {
        if ( $this->data !== null ) {
            return $this->getAllPrefixesPregenerated( $local );
        } else {
            return $this->getAllPrefixesDB( $local );
        }
    }
 
    private static function selectFields() {
        return [
            'iw_prefix',
            'iw_url',
            'iw_api',
            'iw_wikiid',
            'iw_local',
            'iw_trans'
        ];
    }
 
}