8d4aaa43cb
* Avoid direct $GLOBALS lookups. * Avoid MediaWikiServices singleton for Config object. Also given that newFromParams() constructs its Logger object unconditionally as of I2aa835c5ec79, stop creating it ahead of time in ServiceWiring. This code, including the default loggroup value, was duplicated by me from ObjectCache.php to ServiceWiring.php in commits3828558140andbd16c5eb34because I needed to obtain the Logger object in order to send a message to it about how it was created. Solve this debt by letting ServiceWiring access the actual logger that was created by newFromParams() through a new getLogger() object. Change-Id: Ib2de7b22f6c79db0c700fae06269d04fbe27831d
311 lines
10 KiB
PHP
311 lines
10 KiB
PHP
<?php
|
|
/**
|
|
* Functions to get cache objects.
|
|
*
|
|
* 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
|
|
* @ingroup Cache
|
|
*/
|
|
|
|
use MediaWiki\Logger\LoggerFactory;
|
|
use MediaWiki\MediaWikiServices;
|
|
|
|
/**
|
|
* Functions to get cache objects
|
|
*
|
|
* The word "cache" has two main dictionary meanings, and both
|
|
* are used in this factory class. They are:
|
|
*
|
|
* - a) Cache (the computer science definition).
|
|
* A place to store copies or computations on existing data for
|
|
* higher access speeds.
|
|
* - b) Storage.
|
|
* A place to store lightweight data that is not canonically
|
|
* stored anywhere else (e.g. a "hoard" of objects).
|
|
*
|
|
* The former should always use strongly consistent stores, so callers don't
|
|
* have to deal with stale reads. The latter may be eventually consistent, but
|
|
* callers can use BagOStuff:READ_LATEST to see the latest available data.
|
|
*
|
|
* Primary entry points:
|
|
*
|
|
* - ObjectCache::getLocalServerInstance( $fallbackType )
|
|
* Purpose: Memory cache for very hot keys.
|
|
* Stored only on the individual web server (typically APC or APCu for web requests,
|
|
* and EmptyBagOStuff in CLI mode).
|
|
* Not replicated to the other servers.
|
|
*
|
|
* - ObjectCache::getLocalClusterInstance()
|
|
* Purpose: Memory storage for per-cluster coordination and tracking.
|
|
* A typical use case would be a rate limit counter or cache regeneration mutex.
|
|
* Stored centrally within the local data-center. Not replicated to other DCs.
|
|
* Configured by $wgMainCacheType.
|
|
*
|
|
* - ObjectCache::getInstance( $cacheType )
|
|
* Purpose: Special cases (like tiered memory/disk caches).
|
|
* Get a specific cache type by key in $wgObjectCaches.
|
|
*
|
|
* All the above BagOStuff cache instances have their makeKey()
|
|
* method scoped to the *current* wiki ID. Use makeGlobalKey() to avoid this scoping
|
|
* when using keys that need to be shared amongst wikis.
|
|
*
|
|
* @ingroup Cache
|
|
*/
|
|
class ObjectCache {
|
|
/** @var BagOStuff[] Map of (id => BagOStuff) */
|
|
public static $instances = [];
|
|
|
|
/**
|
|
* Get a cached instance of the specified type of cache object.
|
|
*
|
|
* @param string|int $id A key in $wgObjectCaches.
|
|
* @return BagOStuff
|
|
*/
|
|
public static function getInstance( $id ) {
|
|
if ( !isset( self::$instances[$id] ) ) {
|
|
self::$instances[$id] = self::newFromId( $id );
|
|
}
|
|
|
|
return self::$instances[$id];
|
|
}
|
|
|
|
/**
|
|
* Create a new cache object of the specified type.
|
|
*
|
|
* @param string|int $id A key in $wgObjectCaches.
|
|
* @return BagOStuff
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
private static function newFromId( $id ) {
|
|
global $wgObjectCaches;
|
|
|
|
if ( !isset( $wgObjectCaches[$id] ) ) {
|
|
// Always recognize these ones
|
|
if ( $id === CACHE_NONE ) {
|
|
return new EmptyBagOStuff();
|
|
} elseif ( $id === 'hash' ) {
|
|
return new HashBagOStuff();
|
|
}
|
|
|
|
throw new InvalidArgumentException( "Invalid object cache type \"$id\" requested. " .
|
|
"It is not present in \$wgObjectCaches." );
|
|
}
|
|
|
|
return self::newFromParams( $wgObjectCaches[$id] );
|
|
}
|
|
|
|
/**
|
|
* Get the default keyspace for this wiki.
|
|
*
|
|
* This is either the value of the `CachePrefix` configuration variable,
|
|
* or (if the former is unset) the `DBname` configuration variable, with
|
|
* `DBprefix` (if defined).
|
|
*
|
|
* @return string
|
|
*/
|
|
private static function getDefaultKeyspace() {
|
|
global $wgCachePrefix;
|
|
|
|
$keyspace = $wgCachePrefix;
|
|
if ( is_string( $keyspace ) && $keyspace !== '' ) {
|
|
return $keyspace;
|
|
}
|
|
|
|
return WikiMap::getCurrentWikiDbDomain()->getId();
|
|
}
|
|
|
|
/**
|
|
* Create a new cache object from parameters.
|
|
*
|
|
* @param array $params Must have 'factory' or 'class' property.
|
|
* - factory: Callback passed $params that returns BagOStuff.
|
|
* - class: BagOStuff subclass constructed with $params.
|
|
* - loggroup: Alias to set 'logger' key with LoggerFactory group.
|
|
* - .. Other parameters passed to factory or class.
|
|
* @param Config|null $conf (Since 1.35)
|
|
* @return BagOStuff
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public static function newFromParams( array $params, Config $conf = null ) {
|
|
// Apply default parameters and resolve the logger instance
|
|
$params += [
|
|
'logger' => LoggerFactory::getInstance( $params['loggroup'] ?? 'objectcache' ),
|
|
'keyspace' => self::getDefaultKeyspace(),
|
|
'asyncHandler' => [ DeferredUpdates::class, 'addCallableUpdate' ],
|
|
'reportDupes' => true,
|
|
];
|
|
|
|
if ( isset( $params['factory'] ) ) {
|
|
return call_user_func( $params['factory'], $params );
|
|
}
|
|
|
|
if ( !isset( $params['class'] ) ) {
|
|
throw new InvalidArgumentException(
|
|
'No "factory" nor "class" provided; got "' . print_r( $params, true ) . '"'
|
|
);
|
|
}
|
|
|
|
$class = $params['class'];
|
|
// Not passing $conf is deprecated since 1.35
|
|
// NOTE: We cannot use MediaWikiServices::getMainConfig here as fallback,
|
|
// because ObjectCache::newFromParams is used for service wiring and
|
|
// in the ExtensionRegistry, and must not itself cause MediaWikiServices
|
|
// to be initialised. In particular, doing so would break the
|
|
// GlobalPreferences extension, which is overriding a service and then
|
|
// hard-requiring their additional methods to exist on the service object
|
|
// (T210449, T238466).
|
|
// TODO: Hard-deprecate before 1.35 gets cut, and remove in 1.36.
|
|
$conf = $conf ?? new HashConfig( [
|
|
'SQLiteDataDir' => $GLOBALS['wgSQLiteDataDir'],
|
|
'MemCachedServers' => $GLOBALS['wgMemCachedServers'],
|
|
'MemCachedPersistent' => $GLOBALS['wgMemCachedPersistent'],
|
|
'MemCachedTimeout' => $GLOBALS['wgMemCachedTimeout'],
|
|
] );
|
|
|
|
// Do b/c logic for SqlBagOStuff
|
|
if ( is_a( $class, SqlBagOStuff::class, true ) ) {
|
|
if ( isset( $params['server'] ) && !isset( $params['servers'] ) ) {
|
|
$params['servers'] = [ $params['server'] ];
|
|
unset( $params['server'] );
|
|
}
|
|
// In the past it was not required to set 'dbDirectory' in $wgObjectCaches
|
|
if ( isset( $params['servers'] ) ) {
|
|
foreach ( $params['servers'] as &$server ) {
|
|
if ( $server['type'] === 'sqlite' && !isset( $server['dbDirectory'] ) ) {
|
|
$server['dbDirectory'] = $conf->get( 'SQLiteDataDir' );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Do b/c logic for MemcachedBagOStuff
|
|
if ( is_subclass_of( $class, MemcachedBagOStuff::class ) ) {
|
|
$params += [
|
|
'servers' => $conf->get( 'MemCachedServers' ),
|
|
'persistent' => $conf->get( 'MemCachedPersistent' ),
|
|
'timeout' => $conf->get( 'MemCachedTimeout' ),
|
|
];
|
|
}
|
|
|
|
return new $class( $params );
|
|
}
|
|
|
|
/**
|
|
* Factory function for CACHE_ANYTHING (referenced from DefaultSettings.php)
|
|
*
|
|
* CACHE_ANYTHING means that stuff has to be cached, not caching is not an option.
|
|
* If a caching method is configured for any of the main caches ($wgMainCacheType,
|
|
* $wgMessageCacheType, $wgParserCacheType), then CACHE_ANYTHING will effectively
|
|
* be an alias to the configured cache choice for that.
|
|
* If no cache choice is configured (by default $wgMainCacheType is CACHE_NONE),
|
|
* then CACHE_ANYTHING will forward to CACHE_DB.
|
|
*
|
|
* @param array $params
|
|
* @return BagOStuff
|
|
*/
|
|
public static function newAnything( $params ) {
|
|
global $wgMainCacheType, $wgMessageCacheType, $wgParserCacheType;
|
|
$candidates = [ $wgMainCacheType, $wgMessageCacheType, $wgParserCacheType ];
|
|
foreach ( $candidates as $candidate ) {
|
|
if ( $candidate !== CACHE_NONE && $candidate !== CACHE_ANYTHING ) {
|
|
$cache = self::getInstance( $candidate );
|
|
// CACHE_ACCEL might default to nothing if no APCu
|
|
// See includes/ServiceWiring.php
|
|
if ( !( $cache instanceof EmptyBagOStuff ) ) {
|
|
return $cache;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( MediaWikiServices::getInstance()->isServiceDisabled( 'DBLoadBalancer' ) ) {
|
|
// The LoadBalancer is disabled, probably because
|
|
// MediaWikiServices::disableStorageBackend was called.
|
|
$candidate = CACHE_NONE;
|
|
} else {
|
|
$candidate = CACHE_DB;
|
|
}
|
|
|
|
return self::getInstance( $candidate );
|
|
}
|
|
|
|
/**
|
|
* Factory function for CACHE_ACCEL (referenced from DefaultSettings.php)
|
|
*
|
|
* This will look for any APC or APCu style server-local cache.
|
|
* A fallback cache can be specified if none is found.
|
|
*
|
|
* // Direct calls
|
|
* ObjectCache::getLocalServerInstance( $fallbackType );
|
|
*
|
|
* // From $wgObjectCaches via newFromParams()
|
|
* ObjectCache::getLocalServerInstance( [ 'fallback' => $fallbackType ] );
|
|
*
|
|
* @param int|string|array $fallback Fallback cache or parameter map with 'fallback'
|
|
* @return BagOStuff
|
|
* @throws InvalidArgumentException
|
|
* @since 1.27
|
|
*/
|
|
public static function getLocalServerInstance( $fallback = CACHE_NONE ) {
|
|
$cache = MediaWikiServices::getInstance()->getLocalServerObjectCache();
|
|
if ( $cache instanceof EmptyBagOStuff ) {
|
|
if ( is_array( $fallback ) ) {
|
|
$fallback = $fallback['fallback'] ?? CACHE_NONE;
|
|
}
|
|
$cache = self::getInstance( $fallback );
|
|
}
|
|
|
|
return $cache;
|
|
}
|
|
|
|
/**
|
|
* Get the main cluster-local cache object.
|
|
*
|
|
* @since 1.27
|
|
* @return BagOStuff
|
|
*/
|
|
public static function getLocalClusterInstance() {
|
|
global $wgMainCacheType;
|
|
|
|
return self::getInstance( $wgMainCacheType );
|
|
}
|
|
|
|
/**
|
|
* Clear all the cached instances.
|
|
*/
|
|
public static function clear() {
|
|
self::$instances = [];
|
|
}
|
|
|
|
/**
|
|
* Detects which local server cache library is present and returns a configuration for it
|
|
* @since 1.32
|
|
*
|
|
* @return int|string Index to cache in $wgObjectCaches
|
|
*/
|
|
public static function detectLocalServerCache() {
|
|
if ( function_exists( 'apcu_fetch' ) ) {
|
|
// Make sure the APCu methods actually store anything
|
|
if ( PHP_SAPI !== 'cli' || ini_get( 'apc.enable_cli' ) ) {
|
|
return 'apcu';
|
|
}
|
|
} elseif ( function_exists( 'wincache_ucache_get' ) ) {
|
|
return 'wincache';
|
|
}
|
|
|
|
return CACHE_NONE;
|
|
}
|
|
}
|