ObjectCache.php

Go to the documentation of this file.

<?php
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;

class ObjectCache {
    public static $instances = [];
    public static $wanInstances = [];

    public static function getInstance( $id ) {
        if ( !isset( self::$instances[$id] ) ) {
            self::$instances[$id] = self::newFromId( $id );
        }

        return self::$instances[$id];
    }

    public static function getWANInstance( $id ) {
        if ( !isset( self::$wanInstances[$id] ) ) {
            self::$wanInstances[$id] = self::newWANCacheFromId( $id );
        }

        return self::$wanInstances[$id];
    }

    public 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] );
    }

    public static function getDefaultKeyspace() {
        global $wgCachePrefix;

        $keyspace = $wgCachePrefix;
        if ( is_string( $keyspace ) && $keyspace !== '' ) {
            return $keyspace;
        }

        return WikiMap::getCurrentWikiDomain()->getId();
    }

    public static function newFromParams( $params ) {
        $params['logger'] = LoggerFactory::getInstance( $params['loggroup'] ?? 'objectcache' );
        if ( !isset( $params['keyspace'] ) ) {
            $params['keyspace'] = self::getDefaultKeyspace();
        }
        if ( isset( $params['factory'] ) ) {
            return call_user_func( $params['factory'], $params );
        } elseif ( isset( $params['class'] ) ) {
            $class = $params['class'];
            // Automatically set the 'async' update handler
            $params['asyncHandler'] = $params['asyncHandler'] ?? 'DeferredUpdates::addCallableUpdate';
            // Enable reportDupes by default
            $params['reportDupes'] = $params['reportDupes'] ?? true;
            // 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'] = MediaWikiServices::getInstance()
                                ->getMainConfig()->get( 'SQLiteDataDir' );
                        }
                    }
                }
            }

            // Do b/c logic for MemcachedBagOStuff
            if ( is_subclass_of( $class, MemcachedBagOStuff::class ) ) {
                if ( !isset( $params['servers'] ) ) {
                    $params['servers'] = $GLOBALS['wgMemCachedServers'];
                }
                if ( !isset( $params['debug'] ) ) {
                    $params['debug'] = $GLOBALS['wgMemCachedDebug'];
                }
                if ( !isset( $params['persistent'] ) ) {
                    $params['persistent'] = $GLOBALS['wgMemCachedPersistent'];
                }
                if ( !isset( $params['timeout'] ) ) {
                    $params['timeout'] = $GLOBALS['wgMemCachedTimeout'];
                }
            }
            return new $class( $params );
        } else {
            throw new InvalidArgumentException( "The definition of cache type \""
                . print_r( $params, true ) . "\" lacks both "
                . "factory and class parameters." );
        }
    }

    public static function newAnything( $params ) {
        global $wgMainCacheType, $wgMessageCacheType, $wgParserCacheType;
        $candidates = [ $wgMainCacheType, $wgMessageCacheType, $wgParserCacheType ];
        foreach ( $candidates as $candidate ) {
            $cache = false;
            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 );
    }

    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;
    }

    public static function newWANCacheFromId( $id ) {
        global $wgWANObjectCaches, $wgObjectCaches;

        if ( !isset( $wgWANObjectCaches[$id] ) ) {
            throw new UnexpectedValueException(
                "Cache type \"$id\" requested is not present in \$wgWANObjectCaches." );
        }

        $params = $wgWANObjectCaches[$id];
        if ( !isset( $wgObjectCaches[$params['cacheId']] ) ) {
            throw new UnexpectedValueException(
                "Cache type \"{$params['cacheId']}\" is not present in \$wgObjectCaches." );
        }
        $params['store'] = $wgObjectCaches[$params['cacheId']];

        return self::newWANCacheFromParams( $params );
    }

    public static function newWANCacheFromParams( array $params ) {
        global $wgCommandLineMode;

        $services = MediaWikiServices::getInstance();

        $erGroup = $services->getEventRelayerGroup();
        if ( isset( $params['channels'] ) ) {
            foreach ( $params['channels'] as $action => $channel ) {
                $params['relayers'][$action] = $erGroup->getRelayer( $channel );
                $params['channels'][$action] = $channel;
            }
        }
        $params['cache'] = self::newFromParams( $params['store'] );
        $params['logger'] = LoggerFactory::getInstance( $params['loggroup'] ?? 'objectcache' );
        if ( !$wgCommandLineMode ) {
            // Send the statsd data post-send on HTTP requests; avoid in CLI mode (T181385)
            $params['stats'] = $services->getStatsdDataFactory();
            // Let pre-emptive refreshes happen post-send on HTTP requests
            $params['asyncHandler'] = [ DeferredUpdates::class, 'addCallableUpdate' ];
        }
        $class = $params['class'];

        return new $class( $params );
    }

    public static function getLocalClusterInstance() {
        global $wgMainCacheType;

        return self::getInstance( $wgMainCacheType );
    }

    public static function getMainWANInstance() {
        return MediaWikiServices::getInstance()->getMainWANObjectCache();
    }

    public static function getMainStashInstance() {
        return MediaWikiServices::getInstance()->getMainObjectStash();
    }

    public static function clear() {
        self::$instances = [];
        self::$wanInstances = [];
    }

    public static function detectLocalServerCache() {
        if ( function_exists( 'apc_fetch' ) ) {
            return 'apc';
        } elseif ( function_exists( 'apcu_fetch' ) ) {
            return 'apcu';
        } elseif ( function_exists( 'wincache_ucache_get' ) ) {
            return 'wincache';
        }
        return CACHE_NONE;
    }
}