includes/Storage/PageEditStash.php

   1 <?php
   2 /**
   3  * Predictive edit preparation system for MediaWiki page.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  */
  22
  23 namespace MediaWiki\Storage;
  24
  25 use ActorMigration;
  26 use BagOStuff;
  27 use Content;
  28 use Hooks;
  29 use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
  30 use ParserOutput;
  31 use Psr\Log\LoggerInterface;
  32 use stdClass;
  33 use Title;
  34 use User;
  35 use Wikimedia\Rdbms\ILoadBalancer;
  36 use Wikimedia\ScopedCallback;
  37 use WikiPage;
  38
  39 /**
  40  * Class for managing stashed edits used by the page updater classes
  41  *
  42  * @since 1.34
  43  */
  44 class PageEditStash {
  45         /** @var BagOStuff */
  46         private $cache;
  47         /** @var ILoadBalancer */
  48         private $lb;
  49         /** @var LoggerInterface */
  50         private $logger;
  51         /** @var StatsdDataFactoryInterface */
  52         private $stats;
  53         /** @var int */
  54         private $initiator;
  55
  56         const ERROR_NONE = 'stashed';
  57         const ERROR_PARSE = 'error_parse';
  58         const ERROR_CACHE = 'error_cache';
  59         const ERROR_UNCACHEABLE = 'uncacheable';
  60         const ERROR_BUSY = 'busy';
  61
  62         const PRESUME_FRESH_TTL_SEC = 30;
  63         const MAX_CACHE_TTL = 300; // 5 minutes
  64         const MAX_SIGNATURE_TTL = 60;
  65
  66         const MAX_CACHE_RECENT = 2;
  67
  68         const INITIATOR_USER = 1;
  69         const INITIATOR_JOB_OR_CLI = 2;
  70
  71         /**
  72          * @param BagOStuff $cache
  73          * @param ILoadBalancer $lb
  74          * @param LoggerInterface $logger
  75          * @param StatsdDataFactoryInterface $stats
  76          * @param int $initiator Class INITIATOR__* constant
  77          */
  78         public function __construct(
  79                 BagOStuff $cache,
  80                 ILoadBalancer $lb,
  81                 LoggerInterface $logger,
  82                 StatsdDataFactoryInterface $stats,
  83                 $initiator
  84         ) {
  85                 $this->cache = $cache;
  86                 $this->lb = $lb;
  87                 $this->logger = $logger;
  88                 $this->stats = $stats;
  89                 $this->initiator = $initiator;
  90         }
  91
  92         /**
  93          * @param WikiPage $page
  94          * @param Content $content Edit content
  95          * @param User $user
  96          * @param string $summary Edit summary
  97          * @return string Class ERROR_* constant
  98          */
  99         public function parseAndCache( WikiPage $page, Content $content, User $user, $summary ) {
 100                 $logger = $this->logger;
 101
 102                 $title = $page->getTitle();
 103                 $key = $this->getStashKey( $title, $this->getContentHash( $content ), $user );
 104                 $fname = __METHOD__;
 105
 106                 // Use the master DB to allow for fast blocking locks on the "save path" where this
 107                 // value might actually be used to complete a page edit. If the edit submission request
 108                 // happens before this edit stash requests finishes, then the submission will block until
 109                 // the stash request finishes parsing. For the lock acquisition below, there is not much
 110                 // need to duplicate parsing of the same content/user/summary bundle, so try to avoid
 111                 // blocking at all here.
 112                 $dbw = $this->lb->getConnection( DB_MASTER );
 113                 if ( !$dbw->lock( $key, $fname, 0 ) ) {
 114                         // De-duplicate requests on the same key
 115                         return self::ERROR_BUSY;
 116                 }
 117                 /** @noinspection PhpUnusedLocalVariableInspection */
 118                 $unlocker = new ScopedCallback( function () use ( $dbw, $key, $fname ) {
 119                         $dbw->unlock( $key, $fname );
 120                 } );
 121
 122                 $cutoffTime = time() - self::PRESUME_FRESH_TTL_SEC;
 123
 124                 // Reuse any freshly build matching edit stash cache
 125                 $editInfo = $this->getStashValue( $key );
 126                 if ( $editInfo && wfTimestamp( TS_UNIX, $editInfo->timestamp ) >= $cutoffTime ) {
 127                         $alreadyCached = true;
 128                 } else {
 129                         $format = $content->getDefaultFormat();
 130                         $editInfo = $page->prepareContentForEdit( $content, null, $user, $format, false );
 131                         $editInfo->output->setCacheTime( $editInfo->timestamp );
 132                         $alreadyCached = false;
 133                 }
 134
 135                 $context = [ 'cachekey' => $key, 'title' => $title->getPrefixedText() ];
 136
 137                 if ( $editInfo && $editInfo->output ) {
 138                         // Let extensions add ParserOutput metadata or warm other caches
 139                         Hooks::run( 'ParserOutputStashForEdit',
 140                                 [ $page, $content, $editInfo->output, $summary, $user ] );
 141
 142                         if ( $alreadyCached ) {
 143                                 $logger->debug( "Parser output for key '{cachekey}' already cached.", $context );
 144
 145                                 return self::ERROR_NONE;
 146                         }
 147
 148                         $code = $this->storeStashValue(
 149                                 $key,
 150                                 $editInfo->pstContent,
 151                                 $editInfo->output,
 152                                 $editInfo->timestamp,
 153                                 $user
 154                         );
 155
 156                         if ( $code === true ) {
 157                                 $logger->debug( "Cached parser output for key '{cachekey}'.", $context );
 158
 159                                 return self::ERROR_NONE;
 160                         } elseif ( $code === 'uncacheable' ) {
 161                                 $logger->info(
 162                                         "Uncacheable parser output for key '{cachekey}' [{code}].",
 163                                         $context + [ 'code' => $code ]
 164                                 );
 165
 166                                 return self::ERROR_UNCACHEABLE;
 167                         } else {
 168                                 $logger->error(
 169                                         "Failed to cache parser output for key '{cachekey}'.",
 170                                         $context + [ 'code' => $code ]
 171                                 );
 172
 173                                 return self::ERROR_CACHE;
 174                         }
 175                 }
 176
 177                 return self::ERROR_PARSE;
 178         }
 179
 180         /**
 181          * Check that a prepared edit is in cache and still up-to-date
 182          *
 183          * This method blocks if the prepared edit is already being rendered,
 184          * waiting until rendering finishes before doing final validity checks.
 185          *
 186          * The cache is rejected if template or file changes are detected.
 187          * Note that foreign template or file transclusions are not checked.
 188          *
 189          * This returns an object with the following fields:
 190          *   - pstContent: the Content after pre-save-transform
 191          *   - output: the ParserOutput instance
 192          *   - timestamp: the timestamp of the parse
 193          *   - edits: author edit count if they are logged in or NULL otherwise
 194          *
 195          * @param Title $title
 196          * @param Content $content
 197          * @param User $user User to get parser options from
 198          * @return stdClass|bool Returns edit stash object or false on cache miss
 199          */
 200         public function checkCache( Title $title, Content $content, User $user ) {
 201                 if (
 202                         // The context is not an HTTP POST request
 203                         !$user->getRequest()->wasPosted() ||
 204                         // The context is a CLI script or a job runner HTTP POST request
 205                         $this->initiator !== self::INITIATOR_USER ||
 206                         // The editor account is a known bot
 207                         $user->isBot()
 208                 ) {
 209                         // Avoid wasted queries and statsd pollution
 210                         return false;
 211                 }
 212
 213                 $logger = $this->logger;
 214
 215                 $key = $this->getStashKey( $title, $this->getContentHash( $content ), $user );
 216                 $context = [
 217                         'key' => $key,
 218                         'title' => $title->getPrefixedText(),
 219                         'user' => $user->getName()
 220                 ];
 221
 222                 $editInfo = $this->getAndWaitForStashValue( $key );
 223                 if ( !is_object( $editInfo ) || !$editInfo->output ) {
 224                         $this->stats->increment( 'editstash.cache_misses.no_stash' );
 225                         if ( $this->recentStashEntryCount( $user ) > 0 ) {
 226                                 $logger->info( "Empty cache for key '{key}' but not for user.", $context );
 227                         } else {
 228                                 $logger->debug( "Empty cache for key '{key}'.", $context );
 229                         }
 230
 231                         return false;
 232                 }
 233
 234                 $age = time() - wfTimestamp( TS_UNIX, $editInfo->output->getCacheTime() );
 235                 $context['age'] = $age;
 236
 237                 $isCacheUsable = true;
 238                 if ( $age <= self::PRESUME_FRESH_TTL_SEC ) {
 239                         // Assume nothing changed in this time
 240                         $this->stats->increment( 'editstash.cache_hits.presumed_fresh' );
 241                         $logger->debug( "Timestamp-based cache hit for key '{key}'.", $context );
 242                 } elseif ( $user->isAnon() ) {
 243                         $lastEdit = $this->lastEditTime( $user );
 244                         $cacheTime = $editInfo->output->getCacheTime();
 245                         if ( $lastEdit < $cacheTime ) {
 246                                 // Logged-out user made no local upload/template edits in the meantime
 247                                 $this->stats->increment( 'editstash.cache_hits.presumed_fresh' );
 248                                 $logger->debug( "Edit check based cache hit for key '{key}'.", $context );
 249                         } else {
 250                                 $isCacheUsable = false;
 251                                 $this->stats->increment( 'editstash.cache_misses.proven_stale' );
 252                                 $logger->info( "Stale cache for key '{key}' due to outside edits.", $context );
 253                         }
 254                 } else {
 255                         if ( $editInfo->edits === $user->getEditCount() ) {
 256                                 // Logged-in user made no local upload/template edits in the meantime
 257                                 $this->stats->increment( 'editstash.cache_hits.presumed_fresh' );
 258                                 $logger->debug( "Edit count based cache hit for key '{key}'.", $context );
 259                         } else {
 260                                 $isCacheUsable = false;
 261                                 $this->stats->increment( 'editstash.cache_misses.proven_stale' );
 262                                 $logger->info( "Stale cache for key '{key}'due to outside edits.", $context );
 263                         }
 264                 }
 265
 266                 if ( !$isCacheUsable ) {
 267                         return false;
 268                 }
 269
 270                 if ( $editInfo->output->getFlag( 'vary-revision' ) ) {
 271                         // This can be used for the initial parse, e.g. for filters or doEditContent(),
 272                         // but a second parse will be triggered in doEditUpdates(). This is not optimal.
 273                         $logger->info(
 274                                 "Cache for key '{key}' has vary_revision; post-insertion parse inevitable.",
 275                                 $context
 276                         );
 277                 } elseif ( $editInfo->output->getFlag( 'vary-revision-id' ) ) {
 278                         // Similar to the above if we didn't guess the ID correctly.
 279                         $logger->debug(
 280                                 "Cache for key '{key}' has vary_revision_id; post-insertion parse possible.",
 281                                 $context
 282                         );
 283                 }
 284
 285                 return $editInfo;
 286         }
 287
 288         /**
 289          * @param string $key
 290          * @return bool|stdClass
 291          */
 292         private function getAndWaitForStashValue( $key ) {
 293                 $editInfo = $this->getStashValue( $key );
 294
 295                 if ( !$editInfo ) {
 296                         $start = microtime( true );
 297                         // We ignore user aborts and keep parsing. Block on any prior parsing
 298                         // so as to use its results and make use of the time spent parsing.
 299                         // Skip this logic if there no master connection in case this method
 300                         // is called on an HTTP GET request for some reason.
 301                         $dbw = $this->lb->getAnyOpenConnection( $this->lb->getWriterIndex() );
 302                         if ( $dbw && $dbw->lock( $key, __METHOD__, 30 ) ) {
 303                                 $editInfo = $this->getStashValue( $key );
 304                                 $dbw->unlock( $key, __METHOD__ );
 305                         }
 306
 307                         $timeMs = 1000 * max( 0, microtime( true ) - $start );
 308                         $this->stats->timing( 'editstash.lock_wait_time', $timeMs );
 309                 }
 310
 311                 return $editInfo;
 312         }
 313
 314         /**
 315          * @param string $textHash
 316          * @return string|bool Text or false if missing
 317          */
 318         public function fetchInputText( $textHash ) {
 319                 $textKey = $this->cache->makeKey( 'stashedit', 'text', $textHash );
 320
 321                 return $this->cache->get( $textKey );
 322         }
 323
 324         /**
 325          * @param string $text
 326          * @param string $textHash
 327          * @return bool Success
 328          */
 329         public function stashInputText( $text, $textHash ) {
 330                 $textKey = $this->cache->makeKey( 'stashedit', 'text', $textHash );
 331
 332                 return $this->cache->set( $textKey, $text, self::MAX_CACHE_TTL );
 333         }
 334
 335         /**
 336          * @param User $user
 337          * @return string|null TS_MW timestamp or null
 338          */
 339         private function lastEditTime( User $user ) {
 340                 $db = $this->lb->getConnection( DB_REPLICA );
 341                 $actorQuery = ActorMigration::newMigration()->getWhere( $db, 'rc_user', $user, false );
 342                 $time = $db->selectField(
 343                         [ 'recentchanges' ] + $actorQuery['tables'],
 344                         'MAX(rc_timestamp)',
 345                         [ $actorQuery['conds'] ],
 346                         __METHOD__,
 347                         [],
 348                         $actorQuery['joins']
 349                 );
 350
 351                 return wfTimestampOrNull( TS_MW, $time );
 352         }
 353
 354         /**
 355          * Get hash of the content, factoring in model/format
 356          *
 357          * @param Content $content
 358          * @return string
 359          */
 360         private function getContentHash( Content $content ) {
 361                 return sha1( implode( "\n", [
 362                         $content->getModel(),
 363                         $content->getDefaultFormat(),
 364                         $content->serialize( $content->getDefaultFormat() )
 365                 ] ) );
 366         }
 367
 368         /**
 369          * Get the temporary prepared edit stash key for a user
 370          *
 371          * This key can be used for caching prepared edits provided:
 372          *   - a) The $user was used for PST options
 373          *   - b) The parser output was made from the PST using cannonical matching options
 374          *
 375          * @param Title $title
 376          * @param string $contentHash Result of getContentHash()
 377          * @param User $user User to get parser options from
 378          * @return string
 379          */
 380         private function getStashKey( Title $title, $contentHash, User $user ) {
 381                 return $this->cache->makeKey(
 382                         'stashed-edit-info',
 383                         md5( $title->getPrefixedDBkey() ),
 384                         // Account for the edit model/text
 385                         $contentHash,
 386                         // Account for user name related variables like signatures
 387                         md5( $user->getId() . "\n" . $user->getName() )
 388                 );
 389         }
 390
 391         /**
 392          * @param string $hash
 393          * @return string
 394          */
 395         private function getStashParserOutputKey( $hash ) {
 396                 return $this->cache->makeKey( 'stashed-edit-output', $hash );
 397         }
 398
 399         /**
 400          * @param string $key
 401          * @return stdClass|bool Object map (pstContent,output,outputID,timestamp,edits) or false
 402          */
 403         private function getStashValue( $key ) {
 404                 $stashInfo = $this->cache->get( $key );
 405                 if ( !is_object( $stashInfo ) ) {
 406                         return false;
 407                 }
 408
 409                 $parserOutputKey = $this->getStashParserOutputKey( $stashInfo->outputID );
 410                 $parserOutput = $this->cache->get( $parserOutputKey );
 411                 if ( $parserOutput instanceof ParserOutput ) {
 412                         $stashInfo->output = $parserOutput;
 413
 414                         return $stashInfo;
 415                 }
 416
 417                 return false;
 418         }
 419
 420         /**
 421          * Build a value to store in memcached based on the PST content and parser output
 422          *
 423          * This makes a simple version of WikiPage::prepareContentForEdit() as stash info
 424          *
 425          * @param string $key
 426          * @param Content $pstContent Pre-Save transformed content
 427          * @param ParserOutput $parserOutput
 428          * @param string $timestamp TS_MW
 429          * @param User $user
 430          * @return string|bool True or an error code
 431          */
 432         private function storeStashValue(
 433                 $key,
 434                 Content $pstContent,
 435                 ParserOutput $parserOutput,
 436                 $timestamp,
 437                 User $user
 438         ) {
 439                 // If an item is renewed, mind the cache TTL determined by config and parser functions.
 440                 // Put an upper limit on the TTL for sanity to avoid extreme template/file staleness.
 441                 $age = time() - wfTimestamp( TS_UNIX, $parserOutput->getCacheTime() );
 442                 $ttl = min( $parserOutput->getCacheExpiry() - $age, self::MAX_CACHE_TTL );
 443                 // Avoid extremely stale user signature timestamps (T84843)
 444                 if ( $parserOutput->getFlag( 'user-signature' ) ) {
 445                         $ttl = min( $ttl, self::MAX_SIGNATURE_TTL );
 446                 }
 447
 448                 if ( $ttl <= 0 ) {
 449                         return 'uncacheable'; // low TTL due to a tag, magic word, or signature?
 450                 }
 451
 452                 // Store what is actually needed and split the output into another key (T204742)
 453                 $parserOutputID = md5( $key );
 454                 $stashInfo = (object)[
 455                         'pstContent' => $pstContent,
 456                         'outputID'   => $parserOutputID,
 457                         'timestamp'  => $timestamp,
 458                         'edits'      => $user->getEditCount()
 459                 ];
 460
 461                 $ok = $this->cache->set( $key, $stashInfo, $ttl );
 462                 if ( $ok ) {
 463                         $ok = $this->cache->set(
 464                                 $this->getStashParserOutputKey( $parserOutputID ),
 465                                 $parserOutput,
 466                                 $ttl
 467                         );
 468                 }
 469
 470                 if ( $ok ) {
 471                         // These blobs can waste slots in low cardinality memcached slabs
 472                         $this->pruneExcessStashedEntries( $user, $key );
 473                 }
 474
 475                 return $ok ? true : 'store_error';
 476         }
 477
 478         /**
 479          * @param User $user
 480          * @param string $newKey
 481          */
 482         private function pruneExcessStashedEntries( User $user, $newKey ) {
 483                 $key = $this->cache->makeKey( 'stash-edit-recent', sha1( $user->getName() ) );
 484
 485                 $keyList = $this->cache->get( $key ) ?: [];
 486                 if ( count( $keyList ) >= self::MAX_CACHE_RECENT ) {
 487                         $oldestKey = array_shift( $keyList );
 488                         $this->cache->delete( $oldestKey );
 489                 }
 490
 491                 $keyList[] = $newKey;
 492                 $this->cache->set( $key, $keyList, 2 * self::MAX_CACHE_TTL );
 493         }
 494
 495         /**
 496          * @param User $user
 497          * @return int
 498          */
 499         private function recentStashEntryCount( User $user ) {
 500                 $key = $this->cache->makeKey( 'stash-edit-recent', sha1( $user->getName() ) );
 501
 502                 return count( $this->cache->get( $key ) ?: [] );
 503         }
 504 }