MediaWiki  1.30.0
ObjectCache.php
Go to the documentation of this file.
1 <?php
26 
80 class ObjectCache {
82  public static $instances = [];
84  public static $wanInstances = [];
85 
92  public static function getInstance( $id ) {
93  if ( !isset( self::$instances[$id] ) ) {
94  self::$instances[$id] = self::newFromId( $id );
95  }
96 
97  return self::$instances[$id];
98  }
99 
107  public static function getWANInstance( $id ) {
108  if ( !isset( self::$wanInstances[$id] ) ) {
109  self::$wanInstances[$id] = self::newWANCacheFromId( $id );
110  }
111 
112  return self::$wanInstances[$id];
113  }
114 
122  public static function newFromId( $id ) {
124 
125  if ( !isset( $wgObjectCaches[$id] ) ) {
126  // Always recognize these ones
127  if ( $id === CACHE_NONE ) {
128  return new EmptyBagOStuff();
129  } elseif ( $id === 'hash' ) {
130  return new HashBagOStuff();
131  }
132 
133  throw new InvalidArgumentException( "Invalid object cache type \"$id\" requested. " .
134  "It is not present in \$wgObjectCaches." );
135  }
136 
137  return self::newFromParams( $wgObjectCaches[$id] );
138  }
139 
149  public static function getDefaultKeyspace() {
151 
152  $keyspace = $wgCachePrefix;
153  if ( is_string( $keyspace ) && $keyspace !== '' ) {
154  return $keyspace;
155  }
156 
157  return wfWikiID();
158  }
159 
171  public static function newFromParams( $params ) {
172  if ( isset( $params['loggroup'] ) ) {
173  $params['logger'] = LoggerFactory::getInstance( $params['loggroup'] );
174  } else {
175  $params['logger'] = LoggerFactory::getInstance( 'objectcache' );
176  }
177  if ( !isset( $params['keyspace'] ) ) {
178  $params['keyspace'] = self::getDefaultKeyspace();
179  }
180  if ( isset( $params['factory'] ) ) {
181  return call_user_func( $params['factory'], $params );
182  } elseif ( isset( $params['class'] ) ) {
183  $class = $params['class'];
184  // Automatically set the 'async' update handler
185  $params['asyncHandler'] = isset( $params['asyncHandler'] )
186  ? $params['asyncHandler']
187  : 'DeferredUpdates::addCallableUpdate';
188  // Enable reportDupes by default
189  $params['reportDupes'] = isset( $params['reportDupes'] )
190  ? $params['reportDupes']
191  : true;
192  // Do b/c logic for SqlBagOStuff
193  if ( is_a( $class, SqlBagOStuff::class, true ) ) {
194  if ( isset( $params['server'] ) && !isset( $params['servers'] ) ) {
195  $params['servers'] = [ $params['server'] ];
196  unset( $params['server'] );
197  }
198  // In the past it was not required to set 'dbDirectory' in $wgObjectCaches
199  if ( isset( $params['servers'] ) ) {
200  foreach ( $params['servers'] as &$server ) {
201  if ( $server['type'] === 'sqlite' && !isset( $server['dbDirectory'] ) ) {
202  $server['dbDirectory'] = MediaWikiServices::getInstance()
203  ->getMainConfig()->get( 'SQLiteDataDir' );
204  }
205  }
206  }
207  }
208 
209  // Do b/c logic for MemcachedBagOStuff
210  if ( is_subclass_of( $class, MemcachedBagOStuff::class ) ) {
211  if ( !isset( $params['servers'] ) ) {
212  $params['servers'] = $GLOBALS['wgMemCachedServers'];
213  }
214  if ( !isset( $params['debug'] ) ) {
215  $params['debug'] = $GLOBALS['wgMemCachedDebug'];
216  }
217  if ( !isset( $params['persistent'] ) ) {
218  $params['persistent'] = $GLOBALS['wgMemCachedPersistent'];
219  }
220  if ( !isset( $params['timeout'] ) ) {
221  $params['timeout'] = $GLOBALS['wgMemCachedTimeout'];
222  }
223  }
224  return new $class( $params );
225  } else {
226  throw new InvalidArgumentException( "The definition of cache type \""
227  . print_r( $params, true ) . "\" lacks both "
228  . "factory and class parameters." );
229  }
230  }
231 
245  public static function newAnything( $params ) {
248  foreach ( $candidates as $candidate ) {
249  $cache = false;
250  if ( $candidate !== CACHE_NONE && $candidate !== CACHE_ANYTHING ) {
251  $cache = self::getInstance( $candidate );
252  // CACHE_ACCEL might default to nothing if no APCu
253  // See includes/ServiceWiring.php
254  if ( !( $cache instanceof EmptyBagOStuff ) ) {
255  return $cache;
256  }
257  }
258  }
259 
260  if ( MediaWikiServices::getInstance()->isServiceDisabled( 'DBLoadBalancer' ) ) {
261  // The LoadBalancer is disabled, probably because
262  // MediaWikiServices::disableStorageBackend was called.
263  $candidate = CACHE_NONE;
264  } else {
265  $candidate = CACHE_DB;
266  }
267 
268  return self::getInstance( $candidate );
269  }
270 
288  public static function getLocalServerInstance( $fallback = CACHE_NONE ) {
289  $cache = MediaWikiServices::getInstance()->getLocalServerObjectCache();
290  if ( $cache instanceof EmptyBagOStuff ) {
291  if ( is_array( $fallback ) ) {
292  $fallback = isset( $fallback['fallback'] ) ? $fallback['fallback'] : CACHE_NONE;
293  }
295  }
296 
297  return $cache;
298  }
299 
308  public static function newWANCacheFromId( $id ) {
310 
311  if ( !isset( $wgWANObjectCaches[$id] ) ) {
312  throw new UnexpectedValueException(
313  "Cache type \"$id\" requested is not present in \$wgWANObjectCaches." );
314  }
315 
317  if ( !isset( $wgObjectCaches[$params['cacheId']] ) ) {
318  throw new UnexpectedValueException(
319  "Cache type \"{$params['cacheId']}\" is not present in \$wgObjectCaches." );
320  }
321  $params['store'] = $wgObjectCaches[$params['cacheId']];
322 
324  }
325 
334  public static function newWANCacheFromParams( array $params ) {
335  $erGroup = MediaWikiServices::getInstance()->getEventRelayerGroup();
336  foreach ( $params['channels'] as $action => $channel ) {
337  $params['relayers'][$action] = $erGroup->getRelayer( $channel );
338  $params['channels'][$action] = $channel;
339  }
340  $params['cache'] = self::newFromParams( $params['store'] );
341  if ( isset( $params['loggroup'] ) ) {
342  $params['logger'] = LoggerFactory::getInstance( $params['loggroup'] );
343  } else {
344  $params['logger'] = LoggerFactory::getInstance( 'objectcache' );
345  }
346  $class = $params['class'];
347 
348  return new $class( $params );
349  }
350 
357  public static function getLocalClusterInstance() {
359 
361  }
362 
370  public static function getMainWANInstance() {
371  return MediaWikiServices::getInstance()->getMainWANObjectCache();
372  }
373 
393  public static function getMainStashInstance() {
394  return MediaWikiServices::getInstance()->getMainObjectStash();
395  }
396 
400  public static function clear() {
401  self::$instances = [];
402  self::$wanInstances = [];
403  }
404 }
ObjectCache\clear
static clear()
Clear all the cached instances.
Definition: ObjectCache.php:400
ObjectCache\newFromId
static newFromId( $id)
Create a new cache object of the specified type.
Definition: ObjectCache.php:122
ObjectCache
Functions to get cache objects.
Definition: ObjectCache.php:80
ObjectCache\getLocalClusterInstance
static getLocalClusterInstance()
Get the main cluster-local cache object.
Definition: ObjectCache.php:357
HashBagOStuff
Simple store for keeping values in an associative array for the current process.
Definition: HashBagOStuff.php:31
EmptyBagOStuff
A BagOStuff object with no objects in it.
Definition: EmptyBagOStuff.php:29
CACHE_NONE
const CACHE_NONE
Definition: Defines.php:103
$fallback
$fallback
Definition: MessagesAb.php:11
$wgWANObjectCaches
$wgWANObjectCaches
Advanced WAN object cache configuration.
Definition: DefaultSettings.php:2357
use
as see the revision history and available at free of to any person obtaining a copy of this software and associated documentation to deal in the Software without including without limitation the rights to use
Definition: MIT-LICENSE.txt:10
ObjectCache\$instances
static BagOStuff[] $instances
Map of (id => BagOStuff)
Definition: ObjectCache.php:82
$wgMessageCacheType
$wgMessageCacheType
The cache type for storing the contents of the MediaWiki namespace.
Definition: DefaultSettings.php:2254
$params
$params
Definition: styleTest.css.php:40
BagOStuff
interface is intended to be more or less compatible with the PHP memcached client.
Definition: BagOStuff.php:47
php
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:35
ObjectCache\newAnything
static newAnything( $params)
Factory function for CACHE_ANYTHING (referenced from DefaultSettings.php)
Definition: ObjectCache.php:245
ObjectCache\getMainStashInstance
static getMainStashInstance()
Get the cache object for the main stash.
Definition: ObjectCache.php:393
ObjectCache\$wanInstances
static WANObjectCache[] $wanInstances
Map of (id => WANObjectCache)
Definition: ObjectCache.php:84
$wgCachePrefix
$wgCachePrefix
Overwrite the caching key prefix with custom value.
Definition: DefaultSettings.php:6388
ObjectCache\newWANCacheFromParams
static newWANCacheFromParams(array $params)
Create a new cache object of the specified type.
Definition: ObjectCache.php:334
$wgObjectCaches
$wgObjectCaches
Advanced object cache configuration.
Definition: DefaultSettings.php:2294
ObjectCache\getWANInstance
static getWANInstance( $id)
Get a cached instance of the specified type of WAN cache object.
Definition: ObjectCache.php:107
ObjectCache\getInstance
static getInstance( $id)
Get a cached instance of the specified type of cache object.
Definition: ObjectCache.php:92
$wgParserCacheType
$wgParserCacheType
The cache type for storing article HTML.
Definition: DefaultSettings.php:2262
global
when a variable name is used in a it is silently declared as a new masking the global
Definition: design.txt:93
$GLOBALS
$GLOBALS['wgAutoloadClasses']['LocalisationUpdate']
Definition: Autoload.php:10
ObjectCache\newWANCacheFromId
static newWANCacheFromId( $id)
Create a new cache object of the specified type.
Definition: ObjectCache.php:308
wfWikiID
wfWikiID()
Get an ASCII string identifying this wiki This is used as a prefix in memcached keys.
Definition: GlobalFunctions.php:2807
WANObjectCache
Multi-datacenter aware caching interface.
Definition: WANObjectCache.php:80
CACHE_ANYTHING
const CACHE_ANYTHING
Definition: Defines.php:102
ObjectCache\getDefaultKeyspace
static getDefaultKeyspace()
Get the default keyspace for this wiki.
Definition: ObjectCache.php:149
$cache
$cache
Definition: mcc.php:33
ObjectCache\getMainWANInstance
static getMainWANInstance()
Get the main WAN cache object.
Definition: ObjectCache.php:370
$wgMainCacheType
CACHE_MEMCACHED $wgMainCacheType
Definition: memcached.txt:63
as
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such as
Definition: distributors.txt:9
LoggerFactory
MediaWiki Logger LoggerFactory implements a PSR[0] compatible message logging system Named Psr Log LoggerInterface instances can be obtained from the MediaWiki Logger LoggerFactory::getInstance() static method. MediaWiki\Logger\LoggerFactory expects a class implementing the MediaWiki\Logger\Spi interface to act as a factory for new Psr\Log\LoggerInterface instances. The "Spi" in MediaWiki\Logger\Spi stands for "service provider interface". An SPI is an API intended to be implemented or extended by a third party. This software design pattern is intended to enable framework extension and replaceable components. It is specifically used in the MediaWiki\Logger\LoggerFactory service to allow alternate PSR-3 logging implementations to be easily integrated with MediaWiki. The service provider interface allows the backend logging library to be implemented in multiple ways. The $wgMWLoggerDefaultSpi global provides the classname of the default MediaWiki\Logger\Spi implementation to be loaded at runtime. This can either be the name of a class implementing the MediaWiki\Logger\Spi with a zero argument const ructor or a callable that will return an MediaWiki\Logger\Spi instance. Alternately the MediaWiki\Logger\LoggerFactory MediaWiki Logger LoggerFactory
Definition: logger.txt:5
ObjectCache\newFromParams
static newFromParams( $params)
Create a new cache object from parameters.
Definition: ObjectCache.php:171
class
you have access to all of the normal MediaWiki so you can get a DB use the etc For full docs on the Maintenance class
Definition: maintenance.txt:52
MediaWikiServices
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency MediaWikiServices
Definition: injection.txt:23
CACHE_DB
const CACHE_DB
Definition: Defines.php:104
array
the array() calling protocol came about after MediaWiki 1.4rc1.
ObjectCache\getLocalServerInstance
static getLocalServerInstance( $fallback=CACHE_NONE)
Factory function for CACHE_ACCEL (referenced from DefaultSettings.php)
Definition: ObjectCache.php:288