mirror of
https://github.com/YunoHost-Apps/mediawiki_ynh.git
synced 2024-09-03 19:46:05 +02:00
392 lines
10 KiB
PHP
392 lines
10 KiB
PHP
<?php
|
|
/**
|
|
* Cache of various elements in a single cache entry.
|
|
*
|
|
* 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
|
|
* @license GNU GPL v2 or later
|
|
* @author Jeroen De Dauw < jeroendedauw@gmail.com >
|
|
*/
|
|
|
|
/**
|
|
* Interface for all classes implementing CacheHelper functionality.
|
|
*
|
|
* @since 1.20
|
|
*/
|
|
interface ICacheHelper {
|
|
|
|
/**
|
|
* Sets if the cache should be enabled or not.
|
|
*
|
|
* @since 1.20
|
|
* @param boolean $cacheEnabled
|
|
*/
|
|
function setCacheEnabled( $cacheEnabled );
|
|
|
|
/**
|
|
* Initializes the caching.
|
|
* Should be called before the first time anything is added via addCachedHTML.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param integer|null $cacheExpiry Sets the cache expiry, either ttl in seconds or unix timestamp.
|
|
* @param boolean|null $cacheEnabled Sets if the cache should be enabled or not.
|
|
*/
|
|
function startCache( $cacheExpiry = null, $cacheEnabled = null );
|
|
|
|
/**
|
|
* Get a cached value if available or compute it if not and then cache it if possible.
|
|
* The provided $computeFunction is only called when the computation needs to happen
|
|
* and should return a result value. $args are arguments that will be passed to the
|
|
* compute function when called.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param {function} $computeFunction
|
|
* @param array|mixed $args
|
|
* @param string|null $key
|
|
*
|
|
* @return mixed
|
|
*/
|
|
function getCachedValue( $computeFunction, $args = array(), $key = null );
|
|
|
|
/**
|
|
* Saves the HTML to the cache in case it got recomputed.
|
|
* Should be called after the last time anything is added via addCachedHTML.
|
|
*
|
|
* @since 1.20
|
|
*/
|
|
function saveCache();
|
|
|
|
/**
|
|
* Sets the time to live for the cache, in seconds or a unix timestamp
|
|
* indicating the point of expiry...
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param integer $cacheExpiry
|
|
*/
|
|
function setExpiry( $cacheExpiry );
|
|
|
|
}
|
|
|
|
/**
|
|
* Helper class for caching various elements in a single cache entry.
|
|
*
|
|
* To get a cached value or compute it, use getCachedValue like this:
|
|
* $this->getCachedValue( $callback );
|
|
*
|
|
* To add HTML that should be cached, use addCachedHTML like this:
|
|
* $this->addCachedHTML( $callback );
|
|
*
|
|
* The callback function is only called when needed, so do all your expensive
|
|
* computations here. This function should returns the HTML to be cached.
|
|
* It should not add anything to the PageOutput object!
|
|
*
|
|
* Before the first addCachedHTML call, you should call $this->startCache();
|
|
* After adding the last HTML that should be cached, call $this->saveCache();
|
|
*
|
|
* @since 1.20
|
|
*/
|
|
class CacheHelper implements ICacheHelper {
|
|
|
|
/**
|
|
* The time to live for the cache, in seconds or a unix timestamp indicating the point of expiry.
|
|
*
|
|
* @since 1.20
|
|
* @var integer
|
|
*/
|
|
protected $cacheExpiry = 3600;
|
|
|
|
/**
|
|
* List of HTML chunks to be cached (if !hasCached) or that where cached (of hasCached).
|
|
* If not cached already, then the newly computed chunks are added here,
|
|
* if it as cached already, chunks are removed from this list as they are needed.
|
|
*
|
|
* @since 1.20
|
|
* @var array
|
|
*/
|
|
protected $cachedChunks;
|
|
|
|
/**
|
|
* Indicates if the to be cached content was already cached.
|
|
* Null if this information is not available yet.
|
|
*
|
|
* @since 1.20
|
|
* @var boolean|null
|
|
*/
|
|
protected $hasCached = null;
|
|
|
|
/**
|
|
* If the cache is enabled or not.
|
|
*
|
|
* @since 1.20
|
|
* @var boolean
|
|
*/
|
|
protected $cacheEnabled = true;
|
|
|
|
/**
|
|
* Function that gets called when initialization is done.
|
|
*
|
|
* @since 1.20
|
|
* @var callable
|
|
*/
|
|
protected $onInitHandler = false;
|
|
|
|
/**
|
|
* Elements to build a cache key with.
|
|
*
|
|
* @since 1.20
|
|
* @var array
|
|
*/
|
|
protected $cacheKey = array();
|
|
|
|
/**
|
|
* Sets if the cache should be enabled or not.
|
|
*
|
|
* @since 1.20
|
|
* @param boolean $cacheEnabled
|
|
*/
|
|
public function setCacheEnabled( $cacheEnabled ) {
|
|
$this->cacheEnabled = $cacheEnabled;
|
|
}
|
|
|
|
/**
|
|
* Initializes the caching.
|
|
* Should be called before the first time anything is added via addCachedHTML.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param integer|null $cacheExpiry Sets the cache expiry, either ttl in seconds or unix timestamp.
|
|
* @param boolean|null $cacheEnabled Sets if the cache should be enabled or not.
|
|
*/
|
|
public function startCache( $cacheExpiry = null, $cacheEnabled = null ) {
|
|
if ( is_null( $this->hasCached ) ) {
|
|
if ( !is_null( $cacheExpiry ) ) {
|
|
$this->cacheExpiry = $cacheExpiry;
|
|
}
|
|
|
|
if ( !is_null( $cacheEnabled ) ) {
|
|
$this->setCacheEnabled( $cacheEnabled );
|
|
}
|
|
|
|
$this->initCaching();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a message that notifies the user he/she is looking at
|
|
* a cached version of the page, including a refresh link.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param IContextSource $context
|
|
* @param boolean $includePurgeLink
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getCachedNotice( IContextSource $context, $includePurgeLink = true ) {
|
|
if ( $this->cacheExpiry < 86400 * 3650 ) {
|
|
$message = $context->msg(
|
|
'cachedspecial-viewing-cached-ttl',
|
|
$context->getLanguage()->formatDuration( $this->cacheExpiry )
|
|
)->escaped();
|
|
}
|
|
else {
|
|
$message = $context->msg(
|
|
'cachedspecial-viewing-cached-ts'
|
|
)->escaped();
|
|
}
|
|
|
|
if ( $includePurgeLink ) {
|
|
$refreshArgs = $context->getRequest()->getQueryValues();
|
|
unset( $refreshArgs['title'] );
|
|
$refreshArgs['action'] = 'purge';
|
|
|
|
$subPage = $context->getTitle()->getFullText();
|
|
$subPage = explode( '/', $subPage, 2 );
|
|
$subPage = count( $subPage ) > 1 ? $subPage[1] : false;
|
|
|
|
$message .= ' ' . Linker::link(
|
|
$context->getTitle( $subPage ),
|
|
$context->msg( 'cachedspecial-refresh-now' )->escaped(),
|
|
array(),
|
|
$refreshArgs
|
|
);
|
|
}
|
|
|
|
return $message;
|
|
}
|
|
|
|
/**
|
|
* Initializes the caching if not already done so.
|
|
* Should be called before any of the caching functionality is used.
|
|
*
|
|
* @since 1.20
|
|
*/
|
|
protected function initCaching() {
|
|
if ( $this->cacheEnabled && is_null( $this->hasCached ) ) {
|
|
$cachedChunks = wfGetCache( CACHE_ANYTHING )->get( $this->getCacheKeyString() );
|
|
|
|
$this->hasCached = is_array( $cachedChunks );
|
|
$this->cachedChunks = $this->hasCached ? $cachedChunks : array();
|
|
|
|
if ( $this->onInitHandler !== false ) {
|
|
call_user_func( $this->onInitHandler, $this->hasCached );
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a cached value if available or compute it if not and then cache it if possible.
|
|
* The provided $computeFunction is only called when the computation needs to happen
|
|
* and should return a result value. $args are arguments that will be passed to the
|
|
* compute function when called.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param {function} $computeFunction
|
|
* @param array|mixed $args
|
|
* @param string|null $key
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function getCachedValue( $computeFunction, $args = array(), $key = null ) {
|
|
$this->initCaching();
|
|
|
|
if ( $this->cacheEnabled && $this->hasCached ) {
|
|
$value = null;
|
|
|
|
if ( is_null( $key ) ) {
|
|
$itemKey = array_keys( array_slice( $this->cachedChunks, 0, 1 ) );
|
|
$itemKey = array_shift( $itemKey );
|
|
|
|
if ( !is_integer( $itemKey ) ) {
|
|
wfWarn( "Attempted to get item with non-numeric key while the next item in the queue has a key ($itemKey) in " . __METHOD__ );
|
|
}
|
|
elseif ( is_null( $itemKey ) ) {
|
|
wfWarn( "Attempted to get an item while the queue is empty in " . __METHOD__ );
|
|
}
|
|
else {
|
|
$value = array_shift( $this->cachedChunks );
|
|
}
|
|
}
|
|
else {
|
|
if ( array_key_exists( $key, $this->cachedChunks ) ) {
|
|
$value = $this->cachedChunks[$key];
|
|
unset( $this->cachedChunks[$key] );
|
|
}
|
|
else {
|
|
wfWarn( "There is no item with key '$key' in this->cachedChunks in " . __METHOD__ );
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if ( !is_array( $args ) ) {
|
|
$args = array( $args );
|
|
}
|
|
|
|
$value = call_user_func_array( $computeFunction, $args );
|
|
|
|
if ( $this->cacheEnabled ) {
|
|
if ( is_null( $key ) ) {
|
|
$this->cachedChunks[] = $value;
|
|
}
|
|
else {
|
|
$this->cachedChunks[$key] = $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Saves the HTML to the cache in case it got recomputed.
|
|
* Should be called after the last time anything is added via addCachedHTML.
|
|
*
|
|
* @since 1.20
|
|
*/
|
|
public function saveCache() {
|
|
if ( $this->cacheEnabled && $this->hasCached === false && !empty( $this->cachedChunks ) ) {
|
|
wfGetCache( CACHE_ANYTHING )->set( $this->getCacheKeyString(), $this->cachedChunks, $this->cacheExpiry );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the time to live for the cache, in seconds or a unix timestamp
|
|
* indicating the point of expiry...
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param integer $cacheExpiry
|
|
*/
|
|
public function setExpiry( $cacheExpiry ) {
|
|
$this->cacheExpiry = $cacheExpiry;
|
|
}
|
|
|
|
/**
|
|
* Returns the cache key to use to cache this page's HTML output.
|
|
* Is constructed from the special page name and language code.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @return string
|
|
* @throws MWException
|
|
*/
|
|
protected function getCacheKeyString() {
|
|
if ( $this->cacheKey === array() ) {
|
|
throw new MWException( 'No cache key set, so cannot obtain or save the CacheHelper values.' );
|
|
}
|
|
|
|
return call_user_func_array( 'wfMemcKey', $this->cacheKey );
|
|
}
|
|
|
|
/**
|
|
* Sets the cache key that should be used.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param array $cacheKey
|
|
*/
|
|
public function setCacheKey( array $cacheKey ) {
|
|
$this->cacheKey = $cacheKey;
|
|
}
|
|
|
|
/**
|
|
* Rebuild the content, even if it's already cached.
|
|
* This effectively has the same effect as purging the cache,
|
|
* since it will be overridden with the new value on the next request.
|
|
*
|
|
* @since 1.20
|
|
*/
|
|
public function rebuildOnDemand() {
|
|
$this->hasCached = false;
|
|
}
|
|
|
|
/**
|
|
* Sets a function that gets called when initialization of the cache is done.
|
|
*
|
|
* @since 1.20
|
|
*
|
|
* @param $handlerFunction
|
|
*/
|
|
public function setOnInitializedHandler( $handlerFunction ) {
|
|
$this->onInitHandler = $handlerFunction;
|
|
}
|
|
|
|
}
|