PHP wfSharedMemcKey函数代码示例

 protected function getArticleData($pageId)
 {
     global $wgVideoHandlersVideosMigrated;
     $oTitle = Title::newFromID($pageId);
     $oMemCache = F::App()->wg->memc;
     $sKey = wfSharedMemcKey('category_exhibition_article_cache_0', $pageId, F::App()->wg->cityId, $this->isVerify(), $wgVideoHandlersVideosMigrated ? 1 : 0, $this->getTouched($oTitle));
     $cachedResult = $oMemCache->get($sKey);
     if (!empty($cachedResult)) {
         return $cachedResult;
     }
     $snippetText = '';
     $imageUrl = $this->getImageFromPageId($pageId);
     // if category has no images in page content, look for images and articles in category
     if ($imageUrl == '') {
         $resultArray = $this->getCategoryImageOrSnippet($pageId);
         $snippetText = $resultArray['snippetText'];
         $imageUrl = $resultArray['imageUrl'];
         if (empty($snippetText) && empty($imageUrl)) {
             $snippetService = new ArticleService($oTitle);
             $snippetText = $snippetService->getTextSnippet();
         }
     }
     $returnData = array('id' => $pageId, 'title' => $oTitle->getText(), 'url' => $oTitle->getFullURL(), 'img' => $imageUrl, 'width' => $this->thumbWidth, 'height' => $this->thumbHeight, 'sortType' => $this->getSortType(), 'displayType' => $this->getDisplayType(), 'snippet' => $snippetText);
     // will be purged elsewhere after edit
     $oMemCache->set($sKey, $returnData, 60 * 60 * 24 * 7);
     return $returnData;
 }

 private function getGlobalFooterLinks()
 {
     global $wgCityId, $wgContLang, $wgLang, $wgMemc;
     wfProfileIn(__METHOD__);
     $verticalId = WikiFactoryHub::getInstance()->getVerticalId($wgCityId);
     $memcKey = wfSharedMemcKey(self::MEMC_KEY_GLOBAL_FOOTER_LINKS, $wgContLang->getCode(), $wgLang->getCode(), $verticalId, self::MEMC_KEY_GLOBAL_FOOTER_VERSION);
     $globalFooterLinks = $wgMemc->get($memcKey);
     if (!empty($globalFooterLinks)) {
         wfProfileOut(__METHOD__);
         return $globalFooterLinks;
     }
     if (is_null($globalFooterLinks = getMessageAsArray(self::MESSAGE_KEY_GLOBAL_FOOTER_LINKS . '-' . $verticalId))) {
         if (is_null($globalFooterLinks = getMessageAsArray(self::MESSAGE_KEY_GLOBAL_FOOTER_LINKS))) {
             wfProfileOut(__METHOD__);
             WikiaLogger::instance()->error("Global Footer's links not found in messages", ['exception' => new Exception()]);
             return [];
         }
     }
     $parsedLinks = [];
     foreach ($globalFooterLinks as $link) {
         $link = trim($link);
         if (strpos($link, '*') === 0) {
             $parsedLink = parseItem($link);
             if (strpos($parsedLink['text'], 'LICENSE') !== false || $parsedLink['text'] == 'GFDL') {
                 $parsedLink['isLicense'] = true;
             } else {
                 $parsedLink['isLicense'] = false;
             }
             $parsedLinks[] = $parsedLink;
         }
     }
     $wgMemc->set($memcKey, $parsedLinks, self::MEMC_EXPIRY);
     wfProfileOut(__METHOD__);
     return $parsedLinks;
 }

 protected function getExternalData()
 {
     global $wgCityId;
     // Prevent recursive loop
     if ($wgCityId == self::EXTERNAL_DATA_SOURCE_WIKI_ID) {
         return array();
     }
     if (self::$externalData === false) {
         global $wgLang, $wgMemc;
         $code = $wgLang->getCode();
         $key = wfSharedMemcKey('user-command-special-page', 'lang', $code);
         $data = $wgMemc->get($key);
         if (empty($data)) {
             $data = array();
             $external = Http::get($this->getExternalDataUrl($code));
             $external = json_decode($external, true);
             if (is_array($external) && !empty($external['allOptions']) && is_array($external['allOptions'])) {
                 foreach ($external['allOptions'] as $option) {
                     $data[$option['id']] = $option;
                 }
             }
             $wgMemc->set($key, $data, self::EXTERNAL_DATA_CACHE_TTL);
         }
         self::$externalData = $data;
     }
     return self::$externalData;
 }

 /**
  * @group UsingDB
  */
 public function testCache()
 {
     $user = $this->getTestUser();
     //create object here, so we use the same one all the time, that way we can test local cache
     $object = new UserService();
     $cachedLocalUser = $this->invokePrivateMethod('UserService', 'getUserFromLocalCacheById', $user->getId(), $object);
     $cachedLocalUserByName = $this->invokePrivateMethod('UserService', 'getUserFromLocalCacheByName', $user->getName(), $object);
     //values are not cached localy yet
     $this->assertEquals(false, $cachedLocalUser);
     $this->assertEquals(false, $cachedLocalUserByName);
     //cache user, both locally and mem cached
     $this->invokePrivateMethod('UserService', 'cacheUser', $user, $object);
     //do the assertion again, local cache should have hit one
     $cachedLocalUser = $this->invokePrivateMethod('UserService', 'getUserFromLocalCacheById', $user->getId(), $object);
     $cachedLocalUserByName = $this->invokePrivateMethod('UserService', 'getUserFromLocalCacheByName', $user->getName(), $object);
     $this->assertEquals($user, $cachedLocalUser);
     $this->assertEquals($user, $cachedLocalUserByName);
     //check if user was cached in memcache, use new object for that
     $cachedMemCacheById = $this->invokePrivateMethod('UserService', 'getUserFromMemCacheById', $user->getId());
     $cachedMemCacheByName = $this->invokePrivateMethod('UserService', 'getUserFromMemCacheByName', $user->getName());
     $this->assertEquals($user, $cachedMemCacheById);
     $this->assertEquals($user, $cachedMemCacheByName);
     //need for deleting form cache test values
     $sharedIdKey = wfSharedMemcKey("UserCache:" . $user->getId());
     $sharedNameKey = wfSharedMemcKey("UserCache:" . $user->getName());
     //remove user from memcache
     F::app()->wg->memc->delete($sharedIdKey);
     F::app()->wg->memc->delete($sharedNameKey);
     //do assert against memcache again
     $cachedMemCacheById = $this->invokePrivateMethod('UserService', 'getUserFromMemCacheById', $user->getId());
     $cachedMemCacheByName = $this->invokePrivateMethod('UserService', 'getUserFromMemCacheByName', $user->getName());
     $this->assertEquals(false, $cachedMemCacheById);
     $this->assertEquals(false, $cachedMemCacheByName);
 }

 /**
  * @desc Returns an array with all available components configuration
  *
  * @return array
  */
 public function getAllComponents()
 {
     $components = WikiaDataAccess::cache(wfSharedMemcKey(__CLASS__, 'all_components_list_with_details', self::MEMCACHE_VERSION_KEY, $this->userLangCode), Wikia\UI\Factory::MEMCACHE_EXPIRATION, [$this, 'getAllComponentsFromDirectories']);
     $this->initComponents($components);
     $this->includeComponentsAssets($components);
     return $components;
 }

 public function getCommercialUseNotAllowedWikis()
 {
     if (empty(self::$wikiList)) {
         self::$wikiList = WikiaDataAccess::cache(wfSharedMemcKey(self::CACHE_KEY_COMMERCIAL_NOT_ALLOWED), self::CACHE_VALID_TIME, function () {
             return $this->getWikisWithVar();
         });
     }
     return self::$wikiList;
 }

 public function getGameCacheValue()
 {
     $factory = new ScavengerHuntGames();
     $gameId = $this->getVal('gameId', '');
     $readWrite = $this->getVal('readwrite', 0);
     $key = wfSharedMemcKey('ScavengerHuntGameIndex', $gameId, $readWrite ? 1 : 0, ScavengerHuntGames::CACHE_VERSION);
     $this->setVal('key', $key);
     $this->setVal('response', unserialize($factory->getCache()->get($key)));
 }

 function __construct($cache, $key)
 {
     $this->memc = $cache;
     if (empty($key)) {
         throw new Exception('Key is empty');
     }
     $this->key = $key;
     $this->lockKey = wfSharedMemcKey('MemcacheSyncLock', $key);
     $this->instance = uniqid('', true);
 }

 /**
  * @param int $articleId
  * @param int $limit - max limit = 10
  * @return array of articles with details
  */
 public function get($articleId, $limit)
 {
     wfProfileIn(__METHOD__);
     $hubName = $this->getHubName();
     $lang = $this->getContentLangCode();
     $out = \WikiaDataAccess::cache(\wfSharedMemcKey('RecommendationApi', self::RECOMMENDATION_ENGINE, $hubName, $lang, self::MCACHE_VERSION), \WikiaResponse::CACHE_STANDARD, function () use($hubName, $lang) {
         $topArticles = $this->getTopArticles($hubName, $lang);
         return $this->getArticlesInfo($topArticles);
     });
     shuffle($out);
     $out = array_slice($out, 0, $limit);
     wfProfileOut(__METHOD__);
     return $out;
 }

 /**
  * Return memcache key used for given message / variable
  *
  * City ID can be specified to return key for different wiki
  *
  * @param string $messageName message / variable name
  * @param int|bool $cityId city ID (false - default to current wiki)
  * @return string memcache key
  */
 private function getMemcKey($messageName, $cityId = false)
 {
     if ($this->useSharedMemcKey) {
         $wikiId = substr(wfSharedMemcKey(), 0, -1);
     } else {
         $wikiId = is_numeric($cityId) ? $cityId : intval($this->wg->CityId);
         // fix for internal and staff (BugId:15149)
         if ($wikiId == 0) {
             $wikiId = $this->wg->DBname;
         }
     }
     $messageName = str_replace(' ', '_', $messageName);
     return implode(':', array(__CLASS__, $wikiId, $this->wg->Lang->getCode(), $messageName, self::version));
 }

 public static function onWikiFactoryVarChanged($cv_name, $city_id, $value)
 {
     $app = F::app();
     if (self::isWikiaBarConfig($city_id, $cv_name)) {
         Wikia::log(__METHOD__, '', 'Updating WikiaBar config caches after change');
         foreach ($value as $vertical => $languages) {
             foreach ($languages as $language => $content) {
                 $dataMemcKey = wfSharedMemcKey('WikiaBarContents', $vertical, $language, WikiaBarModel::WIKIA_BAR_MCACHE_VERSION);
                 Wikia::log(__METHOD__, '', 'Purging ' . $dataMemcKey);
                 $app->wg->memc->set($dataMemcKey, null);
             }
         }
     }
     return true;
 }

	public function index() {
		global $wgCityId, $wgLang, $wgContLang, $wgMemc;
		$catId = WikiFactoryHub::getInstance()->getCategoryId( $wgCityId );
		$mKey = wfSharedMemcKey( 'mOasisFooterLinks', $wgContLang->getCode(), $wgLang->getCode(), $catId );

		$this->footer_links = $wgMemc->get( $mKey );
		$this->copyright = RequestContext::getMain()->getSkin()->getCopyright();

		if ( empty( $this->footer_links ) ) {
			$this->footer_links = $this->getWikiaFooterLinks();
			$wgMemc->set( $mKey, $this->footer_links, 86400 );
		}

		$this->hub = $this->getHub();
	}

 /**
  * @access private
  *
  * @param String $format	format of list: csv or xml
  */
 private function generateList($format)
 {
     global $wgOut, $wgMemc, $wgExternalSharedDB;
     $res = $wgMemc->get(wfSharedMemcKey("{$format}-city-list"));
     $filename = "{$format}_city_list.{$format}";
     $wgOut->disable();
     if ($format === "xml") {
         header("Content-type: application/xml; charset=UTF-8");
     } else {
         header("Content-type: text/csv; charset=UTF-8");
     }
     $wgOut->sendCacheControl();
     print gzinflate($res);
     exit;
 }

 public static function getImageSrcByTitle($cityId, $articleTitle, $width = null, $height = null)
 {
     global $wgMemc;
     wfProfileIn(__METHOD__);
     $imageKey = wfSharedMemcKey('image_url_from_wiki', $cityId . $articleTitle . $width . $height);
     $imageSrc = $wgMemc->get($imageKey);
     if ($imageSrc === false) {
         $globalFile = GlobalFile::newFromText($articleTitle, $cityId);
         if ($globalFile->exists()) {
             $imageSrc = $globalFile->getCrop($width, $height);
         } else {
             $imageSrc = null;
         }
         $wgMemc->set($imageKey, $imageSrc, 60 * 60 * 24 * 3);
     }
     wfProfileOut(__METHOD__);
     return $imageSrc;
 }

function generateList($format)
{
    global $wgMemc, $wgExternalSharedDB;
    $func = "begin_" . $format;
    $res = $func();
    $dbr = WikiFactory::db(DB_SLAVE, array(), $wgExternalSharedDB);
    $sth = $dbr->select(array("city_list"), array("city_title", "city_lang", "city_url", "city_id"), array("city_public = 1"), __METHOD__);
    while ($row = $dbr->fetchObject($sth)) {
        $row->category = WikiFactory::getCategory($row->city_id);
        $func = "body_" . $format;
        $res .= $func($row);
    }
    $func = "end_" . $format;
    $res .= $func();
    if (!empty($res)) {
        $gz_res = gzdeflate($res, 3);
        $wgMemc->set(wfSharedMemcKey("{$format}-city-list"), $gz_res, 3600 * 6);
    }
}