From f6d65e533c62f6deb21342d4901ece24497b433e Mon Sep 17 00:00:00 2001 From: Pierre Schmitz Date: Thu, 4 Jun 2015 07:31:04 +0200 Subject: Update to MediaWiki 1.25.1 --- includes/poolcounter/PoolCounter.php | 57 +++++++++++++++++++++++++++- includes/poolcounter/PoolCounterRedis.php | 17 +++++++-- includes/poolcounter/PoolWorkArticleView.php | 7 ++-- 3 files changed, 74 insertions(+), 7 deletions(-) (limited to 'includes/poolcounter') diff --git a/includes/poolcounter/PoolCounter.php b/includes/poolcounter/PoolCounter.php index e77ffd7c..5692d731 100644 --- a/includes/poolcounter/PoolCounter.php +++ b/includes/poolcounter/PoolCounter.php @@ -34,7 +34,10 @@ * minutes and hundreds of read hits. * * The PoolCounter provides semaphore semantics for restricting the number - * of workers that may be concurrently performing such single task. + * of workers that may be concurrently performing such single task. Only one + * key can be locked by any PoolCounter instance of a process, except for keys + * that start with "nowait:". However, only 0 timeouts (non-blocking requests) + * can be used with "nowait:" keys. * * By default PoolCounter_Stub is used, which provides no locking. You * can get a useful one in the PoolCounter extension. @@ -67,6 +70,15 @@ abstract class PoolCounter { /** @var float Maximum time in seconds to wait for the lock */ protected $timeout; + /** + * @var boolean Whether the key is a "might wait" key + */ + private $isMightWaitKey; + /** + * @var boolean Whether this process holds a "might wait" lock key + */ + private static $acquiredMightWaitKey = 0; + /** * @param array $conf * @param string $type @@ -84,6 +96,7 @@ abstract class PoolCounter { $key = $this->hashKeyIntoSlots( $key, $this->slots ); } $this->key = $key; + $this->isMightWaitKey = !preg_match( '/^nowait:/', $this->key ); } /** @@ -136,6 +149,48 @@ abstract class PoolCounter { */ abstract public function release(); + /** + * Checks that the lock request is sane. + * @return Status - good for sane requests fatal for insane + * @since 1.25 + */ + final protected function precheckAcquire() { + if ( $this->isMightWaitKey ) { + if ( self::$acquiredMightWaitKey ) { + /* + * The poolcounter itself is quite happy to allow you to wait + * on another lock while you have a lock you waited on already + * but we think that it is unlikely to be a good idea. So we + * made it an error. If you are _really_ _really_ sure it is a + * good idea then feel free to implement an unsafe flag or + * something. + */ + return Status::newFatal( 'poolcounter-usage-error', + 'You may only aquire a single non-nowait lock.' ); + } + } elseif ( $this->timeout !== 0 ) { + return Status::newFatal( 'poolcounter-usage-error', + 'Locks starting in nowait: must have 0 timeout.' ); + } + return Status::newGood(); + } + + /** + * Update any lock tracking information when the lock is acquired + * @since 1.25 + */ + final protected function onAcquire() { + self::$acquiredMightWaitKey |= $this->isMightWaitKey; + } + + /** + * Update any lock tracking information when the lock is released + * @since 1.25 + */ + final protected function onRelease() { + self::$acquiredMightWaitKey &= !$this->isMightWaitKey; + } + /** * Given a key (any string) and the number of lots, returns a slot number (an integer from the [0..($slots-1)] range). * This is used for a global limit on the number of instances of a given type that can acquire a lock. diff --git a/includes/poolcounter/PoolCounterRedis.php b/includes/poolcounter/PoolCounterRedis.php index d609f614..98797a30 100644 --- a/includes/poolcounter/PoolCounterRedis.php +++ b/includes/poolcounter/PoolCounterRedis.php @@ -121,19 +121,26 @@ class PoolCounterRedis extends PoolCounter { } function acquireForMe() { - $section = new ProfileSection( __METHOD__ ); + + $status = $this->precheckAcquire(); + if ( !$status->isGood() ) { + return $status; + } return $this->waitForSlotOrNotif( self::AWAKE_ONE ); } function acquireForAnyone() { - $section = new ProfileSection( __METHOD__ ); + + $status = $this->precheckAcquire(); + if ( !$status->isGood() ) { + return $status; + } return $this->waitForSlotOrNotif( self::AWAKE_ALL ); } function release() { - $section = new ProfileSection( __METHOD__ ); if ( $this->slot === null ) { return Status::newGood( PoolCounter::NOT_LOCKED ); // not locked @@ -207,6 +214,8 @@ LUA; $this->onRelease = null; unset( self::$active[$this->session] ); + $this->onRelease(); + return Status::newGood( PoolCounter::RELEASED ); } @@ -266,6 +275,8 @@ LUA; self::$active[$this->session] = $this; } + $this->onAcquire(); + return Status::newGood( $slot === 'w' ? PoolCounter::DONE : PoolCounter::LOCKED ); } diff --git a/includes/poolcounter/PoolWorkArticleView.php b/includes/poolcounter/PoolWorkArticleView.php index 5e7e3912..a702d2e8 100644 --- a/includes/poolcounter/PoolWorkArticleView.php +++ b/includes/poolcounter/PoolWorkArticleView.php @@ -67,7 +67,8 @@ class PoolWorkArticleView extends PoolCounterWork { $this->parserOptions = $parserOptions; $this->content = $content; $this->cacheKey = ParserCache::singleton()->getKey( $page, $parserOptions ); - parent::__construct( 'ArticleView', $this->cacheKey . ':revid:' . $revid ); + $keyPrefix = $this->cacheKey ?: wfMemcKey( 'articleview', 'missingcachekey' ); + parent::__construct( 'ArticleView', $keyPrefix . ':revid:' . $revid ); } /** @@ -153,12 +154,12 @@ class PoolWorkArticleView extends PoolCounterWork { // Make sure file cache is not used on uncacheable content. // Output that has magic words in it can still use the parser cache // (if enabled), though it will generally expire sooner. - if ( !$this->parserOutput->isCacheable() || $this->parserOutput->containsOldMagic() ) { + if ( !$this->parserOutput->isCacheable() ) { $wgUseFileCache = false; } if ( $isCurrent ) { - $this->page->doCascadeProtectionUpdates( $this->parserOutput ); + $this->page->triggerOpportunisticLinksUpdate( $this->parserOutput ); } return true; -- cgit v1.2.3-54-g00ecf