HTMLCacheUpdater.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Cache;
 
use MediaWiki\Deferred\CdnCacheUpdate;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\Deferred\HtmlFileCacheUpdate;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageReference;
use MediaWiki\Title\TitleFactory;
use Traversable;
 
class HTMLCacheUpdater {
    private $reboundDelay;
    private $useFileCache;
    private $cdnMaxAge;
 
    private $hookRunner;
 
    public const PURGE_NAIVE = 0;
    public const PURGE_PRESEND = 1;
    public const PURGE_REBOUND = 2;
 
    public const PURGE_INTENT_TXROUND_REFLECTED = self::PURGE_PRESEND | self::PURGE_REBOUND;
 
    public const PURGE_URLS_LINKSUPDATE_ONLY = 4;
 
    public const UNLESS_CACHE_MTIME_AFTER = 'unless-timestamp-exceeds';
 
    private $titleFactory;
 
    public function __construct(
        HookContainer $hookContainer,
        TitleFactory $titleFactory,
        $reboundDelay,
        $useFileCache,
        $cdnMaxAge
    ) {
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->titleFactory = $titleFactory;
        $this->reboundDelay = $reboundDelay;
        $this->useFileCache = $useFileCache;
        $this->cdnMaxAge = $cdnMaxAge;
    }
 
    private function fieldHasFlag( $flags, $flag ) {
        return ( ( $flags & $flag ) === $flag );
    }
 
    public function purgeUrls( $urls, $flags = self::PURGE_PRESEND, array $unless = [] ) {
        $minFreshCacheMtime = $unless[self::UNLESS_CACHE_MTIME_AFTER] ?? null;
        if ( $minFreshCacheMtime && time() > ( $minFreshCacheMtime + $this->cdnMaxAge ) ) {
            return;
        }
 
        $urls = is_string( $urls ) ? [ $urls ] : $urls;
 
        $reboundDelay = $this->fieldHasFlag( $flags, self::PURGE_REBOUND )
            ? $this->reboundDelay
            : 0; // no second purge
 
        $update = new CdnCacheUpdate( $urls, [ 'reboundDelay' => $reboundDelay ] );
        if ( $this->fieldHasFlag( $flags, self::PURGE_PRESEND ) ) {
            DeferredUpdates::addUpdate( $update, DeferredUpdates::PRESEND );
        } else {
            $update->doUpdate();
        }
    }
 
    public function purgeTitleUrls( $pages, $flags = self::PURGE_PRESEND, array $unless = [] ) {
        $pages = is_iterable( $pages ) ? $pages : [ $pages ];
        $pageIdentities = [];
 
        foreach ( $pages as $page ) {
            // TODO: We really only need to cast to PageIdentity. We could use a LinkBatch for that.
            $title = $this->titleFactory->newFromPageReference( $page );
 
            if ( $title->canExist() ) {
                $pageIdentities[] = $title;
            }
        }
 
        if ( !$pageIdentities ) {
            return;
        }
 
        if ( $this->useFileCache ) {
            $update = HtmlFileCacheUpdate::newFromPages( $pageIdentities );
            if ( $this->fieldHasFlag( $flags, self::PURGE_PRESEND ) ) {
                DeferredUpdates::addUpdate( $update, DeferredUpdates::PRESEND );
            } else {
                $update->doUpdate();
            }
        }
 
        $minFreshCacheMtime = $unless[self::UNLESS_CACHE_MTIME_AFTER] ?? null;
        if ( !$minFreshCacheMtime || time() <= ( $minFreshCacheMtime + $this->cdnMaxAge ) ) {
            $urls = [];
            foreach ( $pageIdentities as $pi ) {
                $urls = array_merge( $urls, $this->getUrls( $pi, $flags ) );
            }
            $this->purgeUrls( $urls, $flags );
        }
    }
 
    public function getUrls( PageReference $page, int $flags = 0 ): array {
        $title = $this->titleFactory->newFromPageReference( $page );
 
        if ( !$title->canExist() ) {
            return [];
        }
 
        // These urls are affected both by direct revisions as well,
        // as re-rendering of the same content during a LinksUpdate.
        $urls = [
            $title->getInternalURL()
        ];
        // Language variant page views are currently not cached
        // and thus not purged (T250511).
 
        // These urls are only affected by direct revisions, and do not require
        // purging when a LinksUpdate merely rerenders the same content.
        // This exists to avoid large amounts of redundant PURGE traffic (T250261).
        if ( !$this->fieldHasFlag( $flags, self::PURGE_URLS_LINKSUPDATE_ONLY ) ) {
            $urls[] = $title->getInternalURL( 'action=history' );
 
            // Canonical action=raw URLs for user and site config pages (T58874, T261371).
            if ( $title->isUserJsConfigPage() || $title->isSiteJsConfigPage() ) {
                $urls[] = $title->getInternalURL( 'action=raw&ctype=text/javascript' );
            } elseif ( $title->isUserJsonConfigPage() || $title->isSiteJsonConfigPage() ) {
                $urls[] = $title->getInternalURL( 'action=raw&ctype=application/json' );
            } elseif ( $title->isUserCssConfigPage() || $title->isSiteCssConfigPage() ) {
                $urls[] = $title->getInternalURL( 'action=raw&ctype=text/css' );
            }
        }
 
        // Extensions may add novel ways to access this content
        $append = [];
        $mode = $flags & self::PURGE_URLS_LINKSUPDATE_ONLY;
        $this->hookRunner->onHtmlCacheUpdaterAppendUrls( $title, $mode, $append );
        $urls = array_merge( $urls, $append );
 
        // Extensions may add novel ways to access the site overall
        $append = [];
        $this->hookRunner->onHtmlCacheUpdaterVaryUrls( $urls, $append );
        $urls = array_merge( $urls, $append );
 
        // Legacy. TODO: Deprecate this
        $this->hookRunner->onTitleSquidURLs( $title, $urls );
 
        return $urls;
    }
}
 
class_alias( HTMLCacheUpdater::class, 'HtmlCacheUpdater' );