PHP ObjectCache::getInstance方法代码示例

 private static function getVariables()
 {
     ObjectCache::getInstance();
     $site = Site::getInstance();
     define('GUEST_ROLE_ID', (int) $site->getGuestRoleID()->getValue());
     define('SITE_EMAIL', $site->getEmail());
     define('SITE_TITLE', $site->getTitle());
     date_default_timezone_set($site->getTimeZone());
     if ($site->isInMaintenanceMode()) {
         if (!PermissionEngine::getInstance()->currentUserCanDo('bypasssMaintenanceMode')) {
             return;
         }
     }
     $blockEngine = BlockEngine::getInstance();
     $user = CurrentUser::getUserSession();
     $hookEngine = HookEngine::getInstance();
     $router = Router::getInstance();
     $hookEngine->runAction('addStaticRoutes');
     $moduleInCharge = $router->whichModuleHandlesRequest();
     $response = self::getResponse($moduleInCharge);
     http_response_code($response->getResponseCode());
     $headers = $response->getHeaders();
     foreach ($headers as $header => $value) {
         header($header . ": " . $value, true);
     }
     define('PAGE_TYPE', $response->getPageType());
     $blocks = $blockEngine->getBlocks($site->getTheme(), PAGE_TYPE, $user->getRoleID());
     if ($blocks === null) {
         $blocks = array();
     }
     self::render($site, $response, $blocks);
 }

 /**
  * Attempt to load a precomputed document tree for some given wikitext
  * from the cache.
  *
  * @param string $text
  * @param int $flags
  * @return PPNode_Hash_Tree|bool
  */
 protected function cacheGetTree($text, $flags)
 {
     $config = RequestContext::getMain()->getConfig();
     $length = strlen($text);
     $threshold = $config->get('PreprocessorCacheThreshold');
     if ($threshold === false || $length < $threshold || $length > 1000000.0) {
         return false;
     }
     $cache = ObjectCache::getInstance($config->get('MainCacheType'));
     $key = wfMemcKey(defined('static::CACHE_PREFIX') ? static::CACHE_PREFIX : get_called_class(), md5($text), $flags);
     $value = $cache->get($key);
     if (!$value) {
         return false;
     }
     $version = intval(substr($value, 0, 8));
     if ($version !== static::CACHE_VERSION) {
         return false;
     }
     LoggerFactory::getInstance('Preprocessor')->info("Loaded preprocessor output from cache (key: {$key})");
     return substr($value, 8);
 }

 private function buildMinifiedCSS()
 {
     $siteObject = Site::getInstance();
     $minifiedSoFar = "";
     $themesCssFiles = glob(EDUCASK_ROOT . "/site/themes/{$siteObject->getTheme()}/css/*.css");
     foreach ($themesCssFiles as $cssFile) {
         if (!is_readable($cssFile)) {
             continue;
         }
         $rawFile = file_get_contents($cssFile);
         $rawFile = $this->minifyCssString($rawFile);
         $minifiedSoFar .= $rawFile;
     }
     $minifiedSoFar .= $this->getOtherCssFiles();
     $minifiedSoFar .= $this->getRawCss();
     $objectCache = ObjectCache::getInstance();
     $objectCache->setObject('minifiedCSS', $minifiedSoFar, true);
     $response = Response::fiveHundred();
     $response->setRawContent($minifiedSoFar);
     $response->setHeader('Content-Type', "text/css");
     $response->setResponseCode(200);
     return $response;
 }

 /**
  * @param array $options
  *  - config: Config to fetch configuration from. Defaults to the default 'main' config.
  *  - logger: LoggerInterface to use for logging. Defaults to the 'session' channel.
  *  - store: BagOStuff to store session data in.
  */
 public function __construct($options = array())
 {
     if (isset($options['config'])) {
         $this->config = $options['config'];
         if (!$this->config instanceof Config) {
             throw new \InvalidArgumentException('$options[\'config\'] must be an instance of Config');
         }
     } else {
         $this->config = \ConfigFactory::getDefaultInstance()->makeConfig('main');
     }
     if (isset($options['logger'])) {
         if (!$options['logger'] instanceof LoggerInterface) {
             throw new \InvalidArgumentException('$options[\'logger\'] must be an instance of LoggerInterface');
         }
         $this->setLogger($options['logger']);
     } else {
         $this->setLogger(\MediaWiki\Logger\LoggerFactory::getInstance('session'));
     }
     if (isset($options['store'])) {
         if (!$options['store'] instanceof BagOStuff) {
             throw new \InvalidArgumentException('$options[\'store\'] must be an instance of BagOStuff');
         }
         $this->store = $options['store'];
     } else {
         $this->store = \ObjectCache::getInstance($this->config->get('SessionCacheType'));
         $this->store->setLogger($this->logger);
     }
     register_shutdown_function(array($this, 'shutdown'));
 }

 /**
  * Load conversion tables either from the cache or the disk.
  * @private
  * @param bool $fromCache Load from memcached? Defaults to true.
  */
 function loadTables($fromCache = true)
 {
     global $wgLanguageConverterCacheType;
     if ($this->mTablesLoaded) {
         return;
     }
     $this->mTablesLoaded = true;
     $this->mTables = false;
     $cache = ObjectCache::getInstance($wgLanguageConverterCacheType);
     if ($fromCache) {
         wfProfileIn(__METHOD__ . '-cache');
         $this->mTables = $cache->get($this->mCacheKey);
         wfProfileOut(__METHOD__ . '-cache');
     }
     if (!$this->mTables || !array_key_exists(self::CACHE_VERSION_KEY, $this->mTables)) {
         wfProfileIn(__METHOD__ . '-recache');
         // not in cache, or we need a fresh reload.
         // We will first load the default tables
         // then update them using things in MediaWiki:Conversiontable/*
         $this->loadDefaultTables();
         foreach ($this->mVariants as $var) {
             $cached = $this->parseCachedTable($var);
             $this->mTables[$var]->mergeArray($cached);
         }
         $this->postLoadTables();
         $this->mTables[self::CACHE_VERSION_KEY] = true;
         $cache->set($this->mCacheKey, $this->mTables, 43200);
         wfProfileOut(__METHOD__ . '-recache');
     }
 }

/**
 * Get the cache object used by the parser cache
 *
 * @return BagOStuff
 */
function wfGetParserCacheStorage()
{
    global $wgParserCacheType;
    return ObjectCache::getInstance($wgParserCacheType);
}

} else {
    $debug = "\n\nStart request {$wgRequest->getMethod()} {$wgRequest->getRequestURL()}\n";
    if ($wgDebugPrintHttpHeaders) {
        $debug .= "HTTP HEADERS:\n";
        foreach ($wgRequest->getAllHeaders() as $name => $value) {
            $debug .= "{$name}: {$value}\n";
        }
    }
    wfDebug($debug);
}
Profiler::instance()->scopedProfileOut($ps_misc);
$ps_memcached = Profiler::instance()->scopedProfileIn($fname . '-memcached');
$wgMemc = wfGetMainCache();
$messageMemc = wfGetMessageCacheStorage();
$parserMemc = wfGetParserCacheStorage();
wfDebugLog('caches', 'cluster: ' . get_class($wgMemc) . ', WAN: ' . ($wgMainWANCache === CACHE_NONE ? 'CACHE_NONE' : $wgMainWANCache) . ', stash: ' . $wgMainStash . ', message: ' . get_class($messageMemc) . ', parser: ' . get_class($parserMemc) . ', session: ' . get_class(ObjectCache::getInstance($wgSessionCacheType)));
Profiler::instance()->scopedProfileOut($ps_memcached);
// Most of the config is out, some might want to run hooks here.
Hooks::run('SetupAfterCache');
$ps_globals = Profiler::instance()->scopedProfileIn($fname . '-globals');
/**
 * @var Language $wgContLang
 */
$wgContLang = Language::factory($wgLanguageCode);
$wgContLang->initContLang();
// Now that variant lists may be available...
$wgRequest->interpolateTitle();
if (!is_object($wgAuth)) {
    $wgAuth = new MediaWiki\Auth\AuthManagerAuthPlugin();
    Hooks::run('AuthPluginSetup', [&$wgAuth]);
}

 /**
  * Get the cache storage object to use for session storage
  */
 static function getCache()
 {
     global $wgSessionCacheType;
     return ObjectCache::getInstance($wgSessionCacheType);
 }

 public function execute()
 {
     $params = $this->extractRequestParams();
     $title = Title::newFromText($params['title']);
     if (!$title) {
         $this->dieUsageMsg(array('invalidtitle', $params['title']));
     }
     if ($params['session']) {
         $sessionId = $params['session'];
     } else {
         $sessionId = mt_rand(0, 0x7fffffff);
     }
     global $wgUser;
     $sessionKey = wfMemcKey('scribunto-console', $wgUser->getId(), $sessionId);
     $cache = ObjectCache::getInstance(CACHE_ANYTHING);
     $session = null;
     $sessionIsNew = false;
     if ($params['session']) {
         $session = $cache->get($sessionKey);
     }
     if (!isset($session['version'])) {
         $session = $this->newSession();
         $sessionIsNew = true;
     }
     // Create a variable holding the session which will be stored if there
     // are no errors. If there are errors, we don't want to store the current
     // question to the state builder array, since that will cause subsequent
     // requests to fail.
     $newSession = $session;
     if (!empty($params['clear'])) {
         $newSession['size'] -= strlen(implode('', $newSession['questions']));
         $newSession['questions'] = array();
         $session['questions'] = array();
     }
     if (strlen($params['question'])) {
         $newSession['size'] += strlen($params['question']);
         $newSession['questions'][] = $params['question'];
     }
     if ($params['content']) {
         $newSession['size'] += strlen($params['content']) - strlen($newSession['content']);
         $newSession['content'] = $params['content'];
     }
     if ($newSession['size'] > self::SC_MAX_SIZE) {
         $this->dieUsage($this->msg('scribunto-console-too-large')->text(), 'scribunto-console-too-large');
     }
     $result = $this->runConsole(array('title' => $title, 'content' => $newSession['content'], 'prevQuestions' => $session['questions'], 'question' => $params['question']));
     if ($result['type'] === 'error') {
         // Restore the questions array
         $newSession['questions'] = $session['questions'];
     }
     $cache->set($sessionKey, $newSession, self::SC_SESSION_EXPIRY);
     $result['session'] = $sessionId;
     $result['sessionSize'] = $newSession['size'];
     $result['sessionMaxSize'] = self::SC_MAX_SIZE;
     if ($sessionIsNew) {
         $result['sessionIsNew'] = '';
     }
     foreach ($result as $key => $value) {
         $this->getResult()->addValue(null, $key, $value);
     }
 }

/**
 * Get the cache object used by the language converter
 *
 * @return BagOStuff
 */
function wfGetLangConverterCacheStorage()
{
    global $wgLanguageConverterCacheType;
    return ObjectCache::getInstance($wgLanguageConverterCacheType);
}

 private static function setInstance(Site $object)
 {
     self::$instance = $object;
     $objectCache = ObjectCache::getInstance();
     $objectCache->setEncryptedObject("EducaskSiteObject", $object, true);
 }

    $wgDebugLogFile = '';
}
// Backwards compatibility with old password limits
if ($wgMinimalPasswordLength !== false) {
    $wgPasswordPolicy['policies']['default']['MinimalPasswordLength'] = $wgMinimalPasswordLength;
}
if ($wgMaximalPasswordLength !== false) {
    $wgPasswordPolicy['policies']['default']['MaximalPasswordLength'] = $wgMaximalPasswordLength;
}
// Backwards compatibility warning
if (!$wgSessionsInObjectCache && !$wgSessionsInMemcached) {
    wfDeprecated('$wgSessionsInObjectCache = false', '1.27');
    if ($wgSessionHandler) {
        wfDeprecated('$wgSessionsHandler', '1.27');
    }
    $cacheType = get_class(ObjectCache::getInstance($wgSessionCacheType));
    wfDebugLog("Session data will be stored in \"{$cacheType}\" cache with " . "expiry {$wgObjectCacheSessionExpiry} seconds");
}
$wgSessionsInObjectCache = true;
if ($wgPHPSessionHandling !== 'enable' && $wgPHPSessionHandling !== 'warn' && $wgPHPSessionHandling !== 'disable') {
    $wgPHPSessionHandling = 'warn';
}
Profiler::instance()->scopedProfileOut($ps_default);
// Disable MWDebug for command line mode, this prevents MWDebug from eating up
// all the memory from logging SQL queries on maintenance scripts
global $wgCommandLineMode;
if ($wgDebugToolbar && !$wgCommandLineMode) {
    MWDebug::init();
}
if (!class_exists('AutoLoader')) {
    require_once "{$IP}/includes/AutoLoader.php";

 /**
  * Constructor, always call this from child classes.
  */
 public function __construct()
 {
     global $wgMemc, $wgUser, $wgObjectCaches;
     $defaultConfig = new GlobalVarConfig();
     // all the stuff from DefaultSettings.php
     $installerConfig = self::getInstallerConfig($defaultConfig);
     // Reset all services and inject config overrides
     MediaWiki\MediaWikiServices::resetGlobalInstance($installerConfig);
     // Don't attempt to load user language options (T126177)
     // This will be overridden in the web installer with the user-specified language
     RequestContext::getMain()->setLanguage('en');
     // Disable the i18n cache
     // TODO: manage LocalisationCache singleton in MediaWikiServices
     Language::getLocalisationCache()->disableBackend();
     // Disable all global services, since we don't have any configuration yet!
     MediaWiki\MediaWikiServices::disableStorageBackend();
     // Disable object cache (otherwise CACHE_ANYTHING will try CACHE_DB and
     // SqlBagOStuff will then throw since we just disabled wfGetDB)
     $wgObjectCaches = MediaWikiServices::getInstance()->getMainConfig()->get('ObjectCaches');
     $wgMemc = ObjectCache::getInstance(CACHE_NONE);
     // Having a user with id = 0 safeguards us from DB access via User::loadOptions().
     $wgUser = User::newFromId(0);
     RequestContext::getMain()->setUser($wgUser);
     $this->settings = $this->internalDefaults;
     foreach ($this->defaultVarNames as $var) {
         $this->settings[$var] = $GLOBALS[$var];
     }
     $this->doEnvironmentPreps();
     $this->compiledDBs = [];
     foreach (self::getDBTypes() as $type) {
         $installer = $this->getDBInstaller($type);
         if (!$installer->isCompiled()) {
             continue;
         }
         $this->compiledDBs[] = $type;
     }
     $this->parserTitle = Title::newFromText('Installer');
     $this->parserOptions = new ParserOptions($wgUser);
     // language will be wrong :(
     $this->parserOptions->setEditSection(false);
 }

 /**
  * Prepares testing environment.
  */
 protected function setUp()
 {
     $this->cache = ObjectCache::getInstance();
 }