ParsoidOutputAccess.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser\Parsoid;
 
use Config;
use HashConfig;
use IBufferingStatsdDataFactory;
use InvalidArgumentException;
use Language;
use Liuggio\StatsdClient\Factory\StatsdDataFactory;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageRecord;
use MediaWiki\Parser\ParserCacheFactory;
use MediaWiki\Parser\Parsoid\Config\PageConfigFactory;
use MediaWiki\Parser\RevisionOutputCache;
use MediaWiki\Revision\RevisionAccessException;
use MediaWiki\Revision\RevisionLookup;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\SlotRecord;
use ParserCache;
use ParserOptions;
use ParserOutput;
use Status;
use UnexpectedValueException;
use Wikimedia\Parsoid\Config\SiteConfig;
use Wikimedia\Parsoid\Core\ClientError;
use Wikimedia\Parsoid\Core\PageBundle;
use Wikimedia\Parsoid\Core\ResourceLimitExceededException;
use Wikimedia\Parsoid\Parsoid;
use Wikimedia\UUID\GlobalIdGenerator;
 
class ParsoidOutputAccess {
    public const PARSOID_PARSER_CACHE_NAME = 'parsoid';
 
    private const RENDER_ID_KEY = 'parsoid-render-id';
 
    private const PARSOID_PAGE_BUNDLE_KEY = 'parsoid-page-bundle';
 
    public const OPT_FORCE_PARSE = 1;
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::ParsoidCacheConfig
    ];
 
    private $revisionOutputCache;
 
    private $parserCache;
 
    private $globalIdGenerator;
 
    private $stats;
 
    private $parsoidCacheConfig;
 
    private $parsoid;
 
    private $parsoidPageConfigFactory;
 
    private $revisionLookup;
    private $siteConfig;
 
    public function __construct(
        ServiceOptions $options,
        ParserCacheFactory $parserCacheFactory,
        RevisionLookup $revisionLookup,
        GlobalIdGenerator $globalIdGenerator,
        IBufferingStatsdDataFactory $stats,
        Parsoid $parsoid,
        SiteConfig $siteConfig,
        PageConfigFactory $parsoidPageConfigFactory
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->parsoidCacheConfig = new HashConfig( $options->get( MainConfigNames::ParsoidCacheConfig ) );
        $this->revisionOutputCache = $parserCacheFactory
            ->getRevisionOutputCache( self::PARSOID_PARSER_CACHE_NAME );
        $this->parserCache = $parserCacheFactory->getParserCache( self::PARSOID_PARSER_CACHE_NAME );
        $this->revisionLookup = $revisionLookup;
        $this->globalIdGenerator = $globalIdGenerator;
        $this->stats = $stats;
        $this->parsoid = $parsoid;
        $this->siteConfig = $siteConfig;
        $this->parsoidPageConfigFactory = $parsoidPageConfigFactory;
    }
 
    public function supportsContentModel( string $model ): bool {
        if ( $model === CONTENT_MODEL_WIKITEXT ) {
            return true;
        }
 
        return $this->siteConfig->getContentModelHandler( $model ) !== null;
    }
 
    public function getParserOutput(
        PageRecord $page,
        ParserOptions $parserOpts,
        ?RevisionRecord $revision = null,
        int $options = 0
    ): Status {
        $revId = $revision ? $revision->getId() : $page->getLatest();
        if ( !$revision ) {
            $revision = $this->revisionLookup->getRevisionById( $revId );
 
            if ( !$revision ) {
                throw new RevisionAccessException(
                    'Revision {revId} not found',
                    [ 'revId' => $revId ]
                );
            }
        }
 
        $isOld = $revId !== $page->getLatest();
        $statsKey = $isOld ? 'ParsoidOutputAccess.Cache.revision' : 'ParsoidOutputAccess.Cache.parser';
 
        $mainSlot = $revision->getSlot( SlotRecord::MAIN );
        if ( !$this->supportsContentModel( $mainSlot->getModel() ) ) {
            throw new UnexpectedValueException( 'Parsoid does not support content model ' . $mainSlot->getModel() );
        }
 
        if ( !( $options & self::OPT_FORCE_PARSE ) ) {
            $parserOutput = $this->getCachedParserOutput(
                $page,
                $parserOpts,
                $revision,
                $isOld,
                $statsKey
            );
 
            if ( $parserOutput ) {
                return Status::newGood( $parserOutput );
            }
        }
 
        $startTime = microtime( true );
        $status = $this->parse( $page, $parserOpts, $revision );
        $time = microtime( true ) - $startTime;
 
        if ( $status->isOK() ) {
            if ( $time > $this->parsoidCacheConfig->get( 'CacheThresholdTime' ) ) {
                $parserOutput = $status->getValue();
                $now = $parserOutput->getCacheTime();
 
                if ( $isOld ) {
                    $this->revisionOutputCache->save( $parserOutput, $revision, $parserOpts, $now );
                } else {
                    $this->parserCache->save( $parserOutput, $page, $parserOpts, $now );
                }
                $this->stats->increment( $statsKey . '.save.ok' );
            } else {
                $this->stats->increment( $statsKey . '.save.skipfast' );
            }
        } else {
            $this->stats->increment( $statsKey . '.save.notok' );
        }
 
        return $status;
    }
 
    private function parseInternal(
        PageIdentity $page,
        ?RevisionRecord $revision = null,
        Language $languageOverride = null
    ): Status {
        try {
            $langCode = $languageOverride ? $languageOverride->getCode() : null;
            $pageConfig = $this->parsoidPageConfigFactory->create(
                $page,
                null,
                $revision,
                null,
                $langCode
            );
            $startTime = microtime( true );
            $pageBundle = $this->parsoid->wikitext2html(
                $pageConfig,
                [ 'pageBundle' => true ]
            );
            $parserOutput = $this->createParserOutputFromPageBundle( $pageBundle );
            $time = microtime( true ) - $startTime;
            if ( $time > 3 ) {
                LoggerFactory::getInstance( 'slow-parsoid' )
                    ->info( 'Parsing {title} was slow, took {time} seconds', [
                        'time' => number_format( $time, 2 ),
                        'title' => (string)$page,
                    ] );
            }
            return Status::newGood( $parserOutput );
        } catch ( ClientError $e ) {
            return Status::newFatal( 'parsoid-client-error', $e->getMessage() );
        } catch ( ResourceLimitExceededException $e ) {
            return Status::newFatal( 'parsoid-resource-limit-exceeded', $e->getMessage() );
        }
    }
 
    private function createParserOutputFromPageBundle( PageBundle $pageBundle ): ParserOutput {
        $parserOutput = new ParserOutput( $pageBundle->html );
        $parserOutput->setExtensionData(
            self::PARSOID_PAGE_BUNDLE_KEY,
            [
                'parsoid' => $pageBundle->parsoid,
                'mw' => $pageBundle->mw
            ]
        );
 
        return $parserOutput;
    }
 
    public function getParsoidRenderID( ParserOutput $parserOutput ): ParsoidRenderID {
        // XXX: ParserOutput may be coming from the parser cache, so we need to be careful
        // when we change how we store the render key in the ParserOutput object.
        $renderId = $parserOutput->getExtensionData( self::RENDER_ID_KEY );
        if ( !$renderId ) {
            throw new InvalidArgumentException( 'ParserOutput does not have a render ID' );
        }
 
        return ParsoidRenderID::newFromKey( $renderId );
    }
 
    public function getParsoidPageBundle( ParserOutput $parserOutput ): PageBundle {
        $pbData = $parserOutput->getExtensionData( self::PARSOID_PAGE_BUNDLE_KEY );
        return new PageBundle(
            $parserOutput->getRawText(),
            $pbData['parsoid'] ?? [],
            $pbData['mw'] ?? []
        );
    }
 
    protected function getCachedParserOutput(
        PageRecord $page,
        ParserOptions $parserOpts,
        ?RevisionRecord $revision,
        bool $isOld,
        string $statsKey
    ): ?ParserOutput {
        if ( $isOld ) {
            $parserOutput = $this->revisionOutputCache->get( $revision, $parserOpts );
        } else {
            $parserOutput = $this->parserCache->get( $page, $parserOpts );
        }
 
        if ( $parserOutput ) {
            // Ignore cached ParserOutput if it is incomplete,
            // because it was stored by an old version of the code.
            if ( !$parserOutput->getExtensionData( self::PARSOID_PAGE_BUNDLE_KEY )
                || !$parserOutput->getExtensionData( self::RENDER_ID_KEY )
            ) {
                $parserOutput = null;
            }
        }
 
        if ( $parserOutput ) {
            $this->stats->increment( $statsKey . '.get.hit' );
            return $parserOutput;
        } else {
            $this->stats->increment( $statsKey . '.get.miss' );
            return null;
        }
    }
 
    public function parse( PageRecord $page, ParserOptions $parserOpts, ?RevisionRecord $revision ): Status {
        $revId = $revision ? $revision->getId() : $page->getLatest();
 
        $status = $this->parseInternal( $page, $revision, $parserOpts->getTargetLanguage() );
 
        if ( !$status->isOK() ) {
            return $status;
        }
 
        $parserOutput = $status->getValue();
 
        // TODO: when we make tighter integration with Parsoid, render ID should become
        // a standard ParserOutput property. Nothing else needs it now, so don't generate
        // it in ParserCache just yet.
        $parsoidRenderId = new ParsoidRenderID( $revId, $this->globalIdGenerator->newUUIDv1() );
        $parserOutput->setExtensionData( self::RENDER_ID_KEY, $parsoidRenderId->getKey() );
 
        // XXX: ParserOutput should just always record the revision ID and timestamp
        $now = wfTimestampNow();
        $parserOutput->setCacheRevisionId( $revId );
        $parserOutput->setCacheTime( $now );
 
        return $status;
    }
}