ApiStashEdit::getStashKey() - Code Metrics - Inspection of "Daily Inspection: Merge "Add new type SearchIndexF..." - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (098997)

unknown

created 2016-09-26 17:59 UTC

ApiStashEdit::getStashKey() A

↳ Parent: ApiStashEdit

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	3
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 * @author Aaron Schulz
 */

use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;

/**
 * Prepare an edit in shared cache so that it can be reused on edit
 *
 * This endpoint can be called via AJAX as the user focuses on the edit
 * summary box. By the time of submission, the parse may have already
 * finished, and can be immediately used on page save. Certain parser
 * functions like {{REVISIONID}} or {{CURRENTTIME}} may cause the cache
 * to not be used on edit. Template and files used are check for changes
 * since the output was generated. The cache TTL is also kept low for sanity.
 *
 * @ingroup API
 * @since 1.25
 */
class ApiStashEdit extends ApiBase {
	const ERROR_NONE = 'stashed';
	const ERROR_PARSE = 'error_parse';
	const ERROR_CACHE = 'error_cache';
	const ERROR_UNCACHEABLE = 'uncacheable';
	const ERROR_BUSY = 'busy';

	const PRESUME_FRESH_TTL_SEC = 30;
	const MAX_CACHE_TTL = 300; // 5 minutes

	public function execute() {
		$user = $this->getUser();
		$params = $this->extractRequestParams();

		if ( $user->isBot() ) { // sanity
			$this->dieUsage( 'This interface is not supported for bots', 'botsnotsupported' );
		}

		$cache = ObjectCache::getLocalClusterInstance();
		$page = $this->getTitleOrPageId( $params );
		$title = $page->getTitle();

		if ( !ContentHandler::getForModelID( $params['contentmodel'] )
			->isSupportedFormat( $params['contentformat'] )
		) {
			$this->dieUsage( 'Unsupported content model/format', 'badmodelformat' );
		}

		$text = null;
		$textHash = null;
		if ( strlen( $params['stashedtexthash'] ) ) {
			// Load from cache since the client indicates the text is the same as last stash
			$textHash = $params['stashedtexthash'];
			$textKey = $cache->makeKey( 'stashedit', 'text', $textHash );
			$text = $cache->get( $textKey );
			if ( !is_string( $text ) ) {
				$this->dieUsage( 'No stashed text found with the given hash', 'missingtext' );
			}
		} elseif ( $params['text'] !== null ) {
			// Trim and fix newlines so the key SHA1's match (see WebRequest::getText())
			$text = rtrim( str_replace( "\r\n", "\n", $params['text'] ) );
			$textHash = sha1( $text );
		} else {
			$this->dieUsage(
				'The text or stashedtexthash parameter must be given', 'missingtextparam' );
		}

		$textContent = ContentHandler::makeContent(
			$text, $title, $params['contentmodel'], $params['contentformat'] );

		$page = WikiPage::factory( $title );
		if ( $page->exists() ) {
			// Page exists: get the merged content with the proposed change
			$baseRev = Revision::newFromPageId( $page->getId(), $params['baserevid'] );
			if ( !$baseRev ) {
				$this->dieUsage( "No revision ID {$params['baserevid']}", 'missingrev' );
			}
			$currentRev = $page->getRevision();
			if ( !$currentRev ) {
				$this->dieUsage( "No current revision of page ID {$page->getId()}", 'missingrev' );
			}
			// Merge in the new version of the section to get the proposed version
			$editContent = $page->replaceSectionAtRev(
				$params['section'],
				$textContent,
				$params['sectiontitle'],
				$baseRev->getId()
			);
			if ( !$editContent ) {
				$this->dieUsage( 'Could not merge updated section.', 'replacefailed' );
			}
			if ( $currentRev->getId() == $baseRev->getId() ) {
				// Base revision was still the latest; nothing to merge
				$content = $editContent;
			} else {
				// Merge the edit into the current version
				$baseContent = $baseRev->getContent();
				$currentContent = $currentRev->getContent();
				if ( !$baseContent || !$currentContent ) {
					$this->dieUsage( "Missing content for page ID {$page->getId()}", 'missingrev' );
				}
				$handler = ContentHandler::getForModelID( $baseContent->getModel() );
				$content = $handler->merge3( $baseContent, $editContent, $currentContent );
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
			}
		} else {
			// New pages: use the user-provided content model
			$content = $textContent;
		}

		if ( !$content ) { // merge3() failed
			$this->getResult()->addValue( null,
				$this->getModuleName(), [ 'status' => 'editconflict' ] );
			return;
		}

		// The user will abort the AJAX request by pressing "save", so ignore that
		ignore_user_abort( true );

		if ( $user->pingLimiter( 'stashedit' ) ) {
			$status = 'ratelimited';
		} else {
			$status = self::parseAndStash( $page, $content, $user, $params['summary'] );
			$textKey = $cache->makeKey( 'stashedit', 'text', $textHash );
			$cache->set( $textKey, $text, self::MAX_CACHE_TTL );
		}

		$stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
		$stats->increment( "editstash.cache_stores.$status" );

		$this->getResult()->addValue(
			null,
			$this->getModuleName(),
			[
				'status' => $status,
				'texthash' => $textHash
			]
		);
	}

	/**
	 * @param WikiPage $page
	 * @param Content $content Edit content
	 * @param User $user
	 * @param string $summary Edit summary
	 * @return integer ApiStashEdit::ERROR_* constant
	 * @since 1.25
	 */
	public static function parseAndStash( WikiPage $page, Content $content, User $user, $summary ) {
		$cache = ObjectCache::getLocalClusterInstance();
		$logger = LoggerFactory::getInstance( 'StashEdit' );

		$title = $page->getTitle();
		$key = self::getStashKey( $title, self::getContentHash( $content ), $user );

		// Use the master DB for fast blocking locks
		$dbw = wfGetDB( DB_MASTER );
		if ( !$dbw->lock( $key, __METHOD__, 1 ) ) {
			// De-duplicate requests on the same key
			return self::ERROR_BUSY;
		}
		/** @noinspection PhpUnusedLocalVariableInspection */
		$unlocker = new ScopedCallback( function () use ( $dbw, $key ) {
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
			$dbw->unlock( $key, __METHOD__ );
		} );

		$cutoffTime = time() - self::PRESUME_FRESH_TTL_SEC;

		// Reuse any freshly build matching edit stash cache
		$editInfo = $cache->get( $key );
		if ( $editInfo && wfTimestamp( TS_UNIX, $editInfo->timestamp ) >= $cutoffTime ) {
			$alreadyCached = true;
		} else {
			$format = $content->getDefaultFormat();
			$editInfo = $page->prepareContentForEdit( $content, null, $user, $format, false );
			$alreadyCached = false;
		}

		if ( $editInfo && $editInfo->output ) {
			// Let extensions add ParserOutput metadata or warm other caches
			Hooks::run( 'ParserOutputStashForEdit',
				[ $page, $content, $editInfo->output, $summary, $user ] );

			if ( $alreadyCached ) {
				$logger->debug( "Already cached parser output for key '$key' ('$title')." );
				return self::ERROR_NONE;
			}

			list( $stashInfo, $ttl, $code ) = self::buildStashValue(
				$editInfo->pstContent,
				$editInfo->output,
				$editInfo->timestamp,
				$user
			);

			if ( $stashInfo ) {
				$ok = $cache->set( $key, $stashInfo, $ttl );
				if ( $ok ) {
					$logger->debug( "Cached parser output for key '$key' ('$title')." );
					return self::ERROR_NONE;
				} else {
					$logger->error( "Failed to cache parser output for key '$key' ('$title')." );
					return self::ERROR_CACHE;
				}
			} else {
				$logger->info( "Uncacheable parser output for key '$key' ('$title') [$code]." );
				return self::ERROR_UNCACHEABLE;
			}
		}

		return self::ERROR_PARSE;
	}

	/**
	 * Check that a prepared edit is in cache and still up-to-date
	 *
	 * This method blocks if the prepared edit is already being rendered,
	 * waiting until rendering finishes before doing final validity checks.
	 *
	 * The cache is rejected if template or file changes are detected.
	 * Note that foreign template or file transclusions are not checked.
	 *
	 * The result is a map (pstContent,output,timestamp) with fields
	 * extracted directly from WikiPage::prepareContentForEdit().
	 *
	 * @param Title $title
	 * @param Content $content
	 * @param User $user User to get parser options from
	 * @return stdClass|bool Returns false on cache miss
	 */
	public static function checkCache( Title $title, Content $content, User $user ) {
		if ( $user->isBot() ) {
			return false; // bots never stash - don't pollute stats
		}

		$cache = ObjectCache::getLocalClusterInstance();
		$logger = LoggerFactory::getInstance( 'StashEdit' );
		$stats = MediaWikiServices::getInstance()->getStatsdDataFactory();

		$key = self::getStashKey( $title, self::getContentHash( $content ), $user );
		$editInfo = $cache->get( $key );
		if ( !is_object( $editInfo ) ) {
			$start = microtime( true );
			// We ignore user aborts and keep parsing. Block on any prior parsing
			// so as to use its results and make use of the time spent parsing.
			// Skip this logic if there no master connection in case this method
			// is called on an HTTP GET request for some reason.
			$lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
			$dbw = $lb->getAnyOpenConnection( $lb->getWriterIndex() );
			if ( $dbw && $dbw->lock( $key, __METHOD__, 30 ) ) {
				$editInfo = $cache->get( $key );
				$dbw->unlock( $key, __METHOD__ );
			}

			$timeMs = 1000 * max( 0, microtime( true ) - $start );
			$stats->timing( 'editstash.lock_wait_time', $timeMs );
		}

		if ( !is_object( $editInfo ) || !$editInfo->output ) {
			$stats->increment( 'editstash.cache_misses.no_stash' );
			$logger->debug( "Empty cache for key '$key' ('$title'); user '{$user->getName()}'." );
			return false;
		}

		$age = time() - wfTimestamp( TS_UNIX, $editInfo->output->getCacheTime() );
		if ( $age <= self::PRESUME_FRESH_TTL_SEC ) {
			// Assume nothing changed in this time
			$stats->increment( 'editstash.cache_hits.presumed_fresh' );
			$logger->debug( "Timestamp-based cache hit for key '$key' (age: $age sec)." );
		} elseif ( isset( $editInfo->edits ) && $editInfo->edits === $user->getEditCount() ) {
			// Logged-in user made no local upload/template edits in the meantime
			$stats->increment( 'editstash.cache_hits.presumed_fresh' );
			$logger->debug( "Edit count based cache hit for key '$key' (age: $age sec)." );
		} elseif ( $user->isAnon()
			&& self::lastEditTime( $user ) < $editInfo->output->getCacheTime()
		) {
			// Logged-out user made no local upload/template edits in the meantime
			$stats->increment( 'editstash.cache_hits.presumed_fresh' );
			$logger->debug( "Edit check based cache hit for key '$key' (age: $age sec)." );
		} else {
			// User may have changed included content
			$editInfo = false;
		}

		if ( !$editInfo ) {
			$stats->increment( 'editstash.cache_misses.proven_stale' );
			$logger->info( "Stale cache for key '$key'; old key with outside edits. (age: $age sec)" );
		} elseif ( $editInfo->output->getFlag( 'vary-revision' ) ) {
			// This can be used for the initial parse, e.g. for filters or doEditContent(),
			// but a second parse will be triggered in doEditUpdates(). This is not optimal.
			$logger->info( "Cache for key '$key' ('$title') has vary_revision." );
		} elseif ( $editInfo->output->getFlag( 'vary-revision-id' ) ) {
			// Similar to the above if we didn't guess the ID correctly.
			$logger->info( "Cache for key '$key' ('$title') has vary_revision_id." );
		}

		return $editInfo;
	}

	/**
	 * @param User $user
	 * @return string|null TS_MW timestamp or null
	 */
	private static function lastEditTime( User $user ) {
		$time = wfGetDB( DB_REPLICA )->selectField(
			'recentchanges',
			'MAX(rc_timestamp)',
			[ 'rc_user_text' => $user->getName() ],
			__METHOD__
		);

		return wfTimestampOrNull( TS_MW, $time );
	}

	/**
	 * Get hash of the content, factoring in model/format
	 *
	 * @param Content $content
	 * @return string
	 */
	private static function getContentHash( Content $content ) {
		return sha1( implode( "\n", [
			$content->getModel(),
			$content->getDefaultFormat(),
			$content->serialize( $content->getDefaultFormat() )
		] ) );
	}

	/**
	 * Get the temporary prepared edit stash key for a user
	 *
	 * This key can be used for caching prepared edits provided:
	 *   - a) The $user was used for PST options
	 *   - b) The parser output was made from the PST using cannonical matching options
	 *
	 * @param Title $title
	 * @param string $contentHash Result of getContentHash()
	 * @param User $user User to get parser options from
	 * @return string
	 */
	private static function getStashKey( Title $title, $contentHash, User $user ) {
		return ObjectCache::getLocalClusterInstance()->makeKey(
			'prepared-edit',
			md5( $title->getPrefixedDBkey() ),
			// Account for the edit model/text
			$contentHash,
			// Account for user name related variables like signatures
			md5( $user->getId() . "\n" . $user->getName() )
		);
	}

	/**
	 * Build a value to store in memcached based on the PST content and parser output
	 *
	 * This makes a simple version of WikiPage::prepareContentForEdit() as stash info
	 *
	 * @param Content $pstContent Pre-Save transformed content
	 * @param ParserOutput $parserOutput
	 * @param string $timestamp TS_MW
	 * @param User $user
	 * @return array (stash info array, TTL in seconds, info code) or (null, 0, info code)
	 */
	private static function buildStashValue(
		Content $pstContent, ParserOutput $parserOutput, $timestamp, User $user
	) {
		// If an item is renewed, mind the cache TTL determined by config and parser functions.
		// Put an upper limit on the TTL for sanity to avoid extreme template/file staleness.
		$since = time() - wfTimestamp( TS_UNIX, $parserOutput->getTimestamp() );
		$ttl = min( $parserOutput->getCacheExpiry() - $since, self::MAX_CACHE_TTL );
		if ( $ttl <= 0 ) {
			return [ null, 0, 'no_ttl' ];
		}

		// Only store what is actually needed
		$stashInfo = (object)[
			'pstContent' => $pstContent,
			'output'     => $parserOutput,
			'timestamp'  => $timestamp,
			'edits'      => $user->getEditCount()
		];

		return [ $stashInfo, $ttl, 'ok' ];
	}

	public function getAllowedParams() {
		return [
			'title' => [
				ApiBase::PARAM_TYPE => 'string',
				ApiBase::PARAM_REQUIRED => true
			],
			'section' => [
				ApiBase::PARAM_TYPE => 'string',
			],
			'sectiontitle' => [
				ApiBase::PARAM_TYPE => 'string'
			],
			'text' => [
				ApiBase::PARAM_TYPE => 'text',
				ApiBase::PARAM_DFLT => null
			],
			'stashedtexthash' => [
				ApiBase::PARAM_TYPE => 'string',
				ApiBase::PARAM_DFLT => null
			],
			'summary' => [
				ApiBase::PARAM_TYPE => 'string',
			],
			'contentmodel' => [
				ApiBase::PARAM_TYPE => ContentHandler::getContentModels(),
				ApiBase::PARAM_REQUIRED => true
			],
			'contentformat' => [
				ApiBase::PARAM_TYPE => ContentHandler::getAllContentFormats(),
				ApiBase::PARAM_REQUIRED => true
			],
			'baserevid' => [
				ApiBase::PARAM_TYPE => 'integer',
				ApiBase::PARAM_REQUIRED => true
			]
		];
	}

	public function needsToken() {
		return 'csrf';
	}

	public function mustBePosted() {
		return true;
	}

	public function isWriteMode() {
		return true;
	}

	public function isInternal() {
		return true;
	}
}


1			<?php
2			/**
3			* This program is free software; you can redistribute it and/or modify
4			* it under the terms of the GNU General Public License as published by
5			* the Free Software Foundation; either version 2 of the License, or
6			* (at your option) any later version.
7			*
8			* This program is distributed in the hope that it will be useful,
9			* but WITHOUT ANY WARRANTY; without even the implied warranty of
10			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11			* GNU General Public License for more details.
12			*
13			* You should have received a copy of the GNU General Public License along
14			* with this program; if not, write to the Free Software Foundation, Inc.,
15			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16			* http://www.gnu.org/copyleft/gpl.html
17			*
18			* @file
19			* @author Aaron Schulz
20			*/
21
22			use MediaWiki\Logger\LoggerFactory;
23			use MediaWiki\MediaWikiServices;
24
25			/**
26			* Prepare an edit in shared cache so that it can be reused on edit
27			*
28			* This endpoint can be called via AJAX as the user focuses on the edit
29			* summary box. By the time of submission, the parse may have already
30			* finished, and can be immediately used on page save. Certain parser
31			* functions like {{REVISIONID}} or {{CURRENTTIME}} may cause the cache
32			* to not be used on edit. Template and files used are check for changes
33			* since the output was generated. The cache TTL is also kept low for sanity.
34			*
35			* @ingroup API
36			* @since 1.25
37			*/
38			class ApiStashEdit extends ApiBase {
39			const ERROR_NONE = 'stashed';
40			const ERROR_PARSE = 'error_parse';
41			const ERROR_CACHE = 'error_cache';
42			const ERROR_UNCACHEABLE = 'uncacheable';
43			const ERROR_BUSY = 'busy';
44
45			const PRESUME_FRESH_TTL_SEC = 30;
46			const MAX_CACHE_TTL = 300; // 5 minutes
47
48			public function execute() {
49			$user = $this->getUser();
50			$params = $this->extractRequestParams();
51
52			if ( $user->isBot() ) { // sanity
53			$this->dieUsage( 'This interface is not supported for bots', 'botsnotsupported' );
54			}
55
56			$cache = ObjectCache::getLocalClusterInstance();
57			$page = $this->getTitleOrPageId( $params );
58			$title = $page->getTitle();
59
60			if ( !ContentHandler::getForModelID( $params['contentmodel'] )
61			->isSupportedFormat( $params['contentformat'] )
62			) {
63			$this->dieUsage( 'Unsupported content model/format', 'badmodelformat' );
64			}
65
66			$text = null;
67			$textHash = null;
68			if ( strlen( $params['stashedtexthash'] ) ) {
69			// Load from cache since the client indicates the text is the same as last stash
70			$textHash = $params['stashedtexthash'];
71			$textKey = $cache->makeKey( 'stashedit', 'text', $textHash );
72			$text = $cache->get( $textKey );
73			if ( !is_string( $text ) ) {
74			$this->dieUsage( 'No stashed text found with the given hash', 'missingtext' );
75			}
76			} elseif ( $params['text'] !== null ) {
77			// Trim and fix newlines so the key SHA1's match (see WebRequest::getText())
78			$text = rtrim( str_replace( "\r\n", "\n", $params['text'] ) );
79			$textHash = sha1( $text );
80			} else {
81			$this->dieUsage(
82			'The text or stashedtexthash parameter must be given', 'missingtextparam' );
83			}
84
85			$textContent = ContentHandler::makeContent(
86			$text, $title, $params['contentmodel'], $params['contentformat'] );
87
88			$page = WikiPage::factory( $title );
89			if ( $page->exists() ) {
90			// Page exists: get the merged content with the proposed change
91			$baseRev = Revision::newFromPageId( $page->getId(), $params['baserevid'] );
92			if ( !$baseRev ) {
93			$this->dieUsage( "No revision ID {$params['baserevid']}", 'missingrev' );
94			}
95			$currentRev = $page->getRevision();
96			if ( !$currentRev ) {
97			$this->dieUsage( "No current revision of page ID {$page->getId()}", 'missingrev' );
98			}
99			// Merge in the new version of the section to get the proposed version
100			$editContent = $page->replaceSectionAtRev(
101			$params['section'],
102			$textContent,
103			$params['sectiontitle'],
104			$baseRev->getId()
105			);
106			if ( !$editContent ) {
107			$this->dieUsage( 'Could not merge updated section.', 'replacefailed' );
108			}
109			if ( $currentRev->getId() == $baseRev->getId() ) {
110			// Base revision was still the latest; nothing to merge
111			$content = $editContent;
112			} else {
113			// Merge the edit into the current version
114			$baseContent = $baseRev->getContent();
115			$currentContent = $currentRev->getContent();
116			if ( !$baseContent \|\| !$currentContent ) {
117			$this->dieUsage( "Missing content for page ID {$page->getId()}", 'missingrev' );
118			}
119			$handler = ContentHandler::getForModelID( $baseContent->getModel() );
120			$content = $handler->merge3( $baseContent, $editContent, $currentContent );
			0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report It seems like `$editContent` defined by `$page->replaceSectionAtR...e'], $baseRev->getId())` on line `100` can also be of type `null` or `string`; however, `ContentHandler::merge3()` does only seem to accept `object<Content>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
121			}
122			} else {
123			// New pages: use the user-provided content model
124			$content = $textContent;
125			}
126
127			if ( !$content ) { // merge3() failed
128			$this->getResult()->addValue( null,
129			$this->getModuleName(), [ 'status' => 'editconflict' ] );
130			return;
131			}
132
133			// The user will abort the AJAX request by pressing "save", so ignore that
134			ignore_user_abort( true );
135
136			if ( $user->pingLimiter( 'stashedit' ) ) {
137			$status = 'ratelimited';
138			} else {
139			$status = self::parseAndStash( $page, $content, $user, $params['summary'] );
140			$textKey = $cache->makeKey( 'stashedit', 'text', $textHash );
141			$cache->set( $textKey, $text, self::MAX_CACHE_TTL );
142			}
143
144			$stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
145			$stats->increment( "editstash.cache_stores.$status" );
146
147			$this->getResult()->addValue(
148			null,
149			$this->getModuleName(),
150			[
151			'status' => $status,
152			'texthash' => $textHash
153			]
154			);
155			}
156
157			/**
158			* @param WikiPage $page
159			* @param Content $content Edit content
160			* @param User $user
161			* @param string $summary Edit summary
162			* @return integer ApiStashEdit::ERROR_* constant
163			* @since 1.25
164			*/
165			public static function parseAndStash( WikiPage $page, Content $content, User $user, $summary ) {
166			$cache = ObjectCache::getLocalClusterInstance();
167			$logger = LoggerFactory::getInstance( 'StashEdit' );
168
169			$title = $page->getTitle();
170			$key = self::getStashKey( $title, self::getContentHash( $content ), $user );
171
172			// Use the master DB for fast blocking locks
173			$dbw = wfGetDB( DB_MASTER );
174			if ( !$dbw->lock( $key, __METHOD__, 1 ) ) {
175			// De-duplicate requests on the same key
176			return self::ERROR_BUSY;
177			}
178			/** @noinspection PhpUnusedLocalVariableInspection */
179			$unlocker = new ScopedCallback( function () use ( $dbw, $key ) {
			0 ignored issues – show Unused Code introduced 2016-08-11 17:53 UTC by Report Bug Copy Issue Report `$unlocker` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
180			$dbw->unlock( $key, __METHOD__ );
181			} );
182
183			$cutoffTime = time() - self::PRESUME_FRESH_TTL_SEC;
184
185			// Reuse any freshly build matching edit stash cache
186			$editInfo = $cache->get( $key );
187			if ( $editInfo && wfTimestamp( TS_UNIX, $editInfo->timestamp ) >= $cutoffTime ) {
188			$alreadyCached = true;
189			} else {
190			$format = $content->getDefaultFormat();
191			$editInfo = $page->prepareContentForEdit( $content, null, $user, $format, false );
192			$alreadyCached = false;
193			}
194
195			if ( $editInfo && $editInfo->output ) {
196			// Let extensions add ParserOutput metadata or warm other caches
197			Hooks::run( 'ParserOutputStashForEdit',
198			[ $page, $content, $editInfo->output, $summary, $user ] );
199
200			if ( $alreadyCached ) {
201			$logger->debug( "Already cached parser output for key '$key' ('$title')." );
202			return self::ERROR_NONE;
203			}
204
205			list( $stashInfo, $ttl, $code ) = self::buildStashValue(
206			$editInfo->pstContent,
207			$editInfo->output,
208			$editInfo->timestamp,
209			$user
210			);
211
212			if ( $stashInfo ) {
213			$ok = $cache->set( $key, $stashInfo, $ttl );
214			if ( $ok ) {
215			$logger->debug( "Cached parser output for key '$key' ('$title')." );
216			return self::ERROR_NONE;
217			} else {
218			$logger->error( "Failed to cache parser output for key '$key' ('$title')." );
219			return self::ERROR_CACHE;
220			}
221			} else {
222			$logger->info( "Uncacheable parser output for key '$key' ('$title') [$code]." );
223			return self::ERROR_UNCACHEABLE;
224			}
225			}
226
227			return self::ERROR_PARSE;
228			}
229
230			/**
231			* Check that a prepared edit is in cache and still up-to-date
232			*
233			* This method blocks if the prepared edit is already being rendered,
234			* waiting until rendering finishes before doing final validity checks.
235			*
236			* The cache is rejected if template or file changes are detected.
237			* Note that foreign template or file transclusions are not checked.
238			*
239			* The result is a map (pstContent,output,timestamp) with fields
240			* extracted directly from WikiPage::prepareContentForEdit().
241			*
242			* @param Title $title
243			* @param Content $content
244			* @param User $user User to get parser options from
245			* @return stdClass\|bool Returns false on cache miss
246			*/
247			public static function checkCache( Title $title, Content $content, User $user ) {
248			if ( $user->isBot() ) {
249			return false; // bots never stash - don't pollute stats
250			}
251
252			$cache = ObjectCache::getLocalClusterInstance();
253			$logger = LoggerFactory::getInstance( 'StashEdit' );
254			$stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
255
256			$key = self::getStashKey( $title, self::getContentHash( $content ), $user );
257			$editInfo = $cache->get( $key );
258			if ( !is_object( $editInfo ) ) {
259			$start = microtime( true );
260			// We ignore user aborts and keep parsing. Block on any prior parsing
261			// so as to use its results and make use of the time spent parsing.
262			// Skip this logic if there no master connection in case this method
263			// is called on an HTTP GET request for some reason.
264			$lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
265			$dbw = $lb->getAnyOpenConnection( $lb->getWriterIndex() );
266			if ( $dbw && $dbw->lock( $key, __METHOD__, 30 ) ) {
267			$editInfo = $cache->get( $key );
268			$dbw->unlock( $key, __METHOD__ );
269			}
270
271			$timeMs = 1000 * max( 0, microtime( true ) - $start );
272			$stats->timing( 'editstash.lock_wait_time', $timeMs );
273			}
274
275			if ( !is_object( $editInfo ) \|\| !$editInfo->output ) {
276			$stats->increment( 'editstash.cache_misses.no_stash' );
277			$logger->debug( "Empty cache for key '$key' ('$title'); user '{$user->getName()}'." );
278			return false;
279			}
280
281			$age = time() - wfTimestamp( TS_UNIX, $editInfo->output->getCacheTime() );
282			if ( $age <= self::PRESUME_FRESH_TTL_SEC ) {
283			// Assume nothing changed in this time
284			$stats->increment( 'editstash.cache_hits.presumed_fresh' );
285			$logger->debug( "Timestamp-based cache hit for key '$key' (age: $age sec)." );
286			} elseif ( isset( $editInfo->edits ) && $editInfo->edits === $user->getEditCount() ) {
287			// Logged-in user made no local upload/template edits in the meantime
288			$stats->increment( 'editstash.cache_hits.presumed_fresh' );
289			$logger->debug( "Edit count based cache hit for key '$key' (age: $age sec)." );
290			} elseif ( $user->isAnon()
291			&& self::lastEditTime( $user ) < $editInfo->output->getCacheTime()
292			) {
293			// Logged-out user made no local upload/template edits in the meantime
294			$stats->increment( 'editstash.cache_hits.presumed_fresh' );
295			$logger->debug( "Edit check based cache hit for key '$key' (age: $age sec)." );
296			} else {
297			// User may have changed included content
298			$editInfo = false;
299			}
300
301			if ( !$editInfo ) {
302			$stats->increment( 'editstash.cache_misses.proven_stale' );
303			$logger->info( "Stale cache for key '$key'; old key with outside edits. (age: $age sec)" );
304			} elseif ( $editInfo->output->getFlag( 'vary-revision' ) ) {
305			// This can be used for the initial parse, e.g. for filters or doEditContent(),
306			// but a second parse will be triggered in doEditUpdates(). This is not optimal.
307			$logger->info( "Cache for key '$key' ('$title') has vary_revision." );
308			} elseif ( $editInfo->output->getFlag( 'vary-revision-id' ) ) {
309			// Similar to the above if we didn't guess the ID correctly.
310			$logger->info( "Cache for key '$key' ('$title') has vary_revision_id." );
311			}
312
313			return $editInfo;
314			}
315
316			/**
317			* @param User $user
318			* @return string\|null TS_MW timestamp or null
319			*/
320			private static function lastEditTime( User $user ) {
321			$time = wfGetDB( DB_REPLICA )->selectField(
322			'recentchanges',
323			'MAX(rc_timestamp)',
324			[ 'rc_user_text' => $user->getName() ],
325			__METHOD__
326			);
327
328			return wfTimestampOrNull( TS_MW, $time );
329			}
330
331			/**
332			* Get hash of the content, factoring in model/format
333			*
334			* @param Content $content
335			* @return string
336			*/
337			private static function getContentHash( Content $content ) {
338			return sha1( implode( "\n", [
339			$content->getModel(),
340			$content->getDefaultFormat(),
341			$content->serialize( $content->getDefaultFormat() )
342			] ) );
343			}
344
345			/**
346			* Get the temporary prepared edit stash key for a user
347			*
348			* This key can be used for caching prepared edits provided:
349			* - a) The $user was used for PST options
350			* - b) The parser output was made from the PST using cannonical matching options
351			*
352			* @param Title $title
353			* @param string $contentHash Result of getContentHash()
354			* @param User $user User to get parser options from
355			* @return string
356			*/
357			private static function getStashKey( Title $title, $contentHash, User $user ) {
358			return ObjectCache::getLocalClusterInstance()->makeKey(
359			'prepared-edit',
360			md5( $title->getPrefixedDBkey() ),
361			// Account for the edit model/text
362			$contentHash,
363			// Account for user name related variables like signatures
364			md5( $user->getId() . "\n" . $user->getName() )
365			);
366			}
367
368			/**
369			* Build a value to store in memcached based on the PST content and parser output
370			*
371			* This makes a simple version of WikiPage::prepareContentForEdit() as stash info
372			*
373			* @param Content $pstContent Pre-Save transformed content
374			* @param ParserOutput $parserOutput
375			* @param string $timestamp TS_MW
376			* @param User $user
377			* @return array (stash info array, TTL in seconds, info code) or (null, 0, info code)
378			*/
379			private static function buildStashValue(
380			Content $pstContent, ParserOutput $parserOutput, $timestamp, User $user
381			) {
382			// If an item is renewed, mind the cache TTL determined by config and parser functions.
383			// Put an upper limit on the TTL for sanity to avoid extreme template/file staleness.
384			$since = time() - wfTimestamp( TS_UNIX, $parserOutput->getTimestamp() );
385			$ttl = min( $parserOutput->getCacheExpiry() - $since, self::MAX_CACHE_TTL );
386			if ( $ttl <= 0 ) {
387			return [ null, 0, 'no_ttl' ];
388			}
389
390			// Only store what is actually needed
391			$stashInfo = (object)[
392			'pstContent' => $pstContent,
393			'output' => $parserOutput,
394			'timestamp' => $timestamp,
395			'edits' => $user->getEditCount()
396			];
397
398			return [ $stashInfo, $ttl, 'ok' ];
399			}
400
401			public function getAllowedParams() {
402			return [
403			'title' => [
404			ApiBase::PARAM_TYPE => 'string',
405			ApiBase::PARAM_REQUIRED => true
406			],
407			'section' => [
408			ApiBase::PARAM_TYPE => 'string',
409			],
410			'sectiontitle' => [
411			ApiBase::PARAM_TYPE => 'string'
412			],
413			'text' => [
414			ApiBase::PARAM_TYPE => 'text',
415			ApiBase::PARAM_DFLT => null
416			],
417			'stashedtexthash' => [
418			ApiBase::PARAM_TYPE => 'string',
419			ApiBase::PARAM_DFLT => null
420			],
421			'summary' => [
422			ApiBase::PARAM_TYPE => 'string',
423			],
424			'contentmodel' => [
425			ApiBase::PARAM_TYPE => ContentHandler::getContentModels(),
426			ApiBase::PARAM_REQUIRED => true
427			],
428			'contentformat' => [
429			ApiBase::PARAM_TYPE => ContentHandler::getAllContentFormats(),
430			ApiBase::PARAM_REQUIRED => true
431			],
432			'baserevid' => [
433			ApiBase::PARAM_TYPE => 'integer',
434			ApiBase::PARAM_REQUIRED => true
435			]
436			];
437			}
438
439			public function needsToken() {
440			return 'csrf';
441			}
442
443			public function mustBePosted() {
444			return true;
445			}
446
447			public function isWriteMode() {
448			return true;
449			}
450
451			public function isInternal() {
452			return true;
453			}
454			}
455

wikimedia / mediawiki

Branch — master (098997)

ApiStashEdit::getStashKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like