/** * @test */ public function getOnSecondaryCacheIsNeverCalledWhenValueIsPresentInFirstLevelCache() { $this->secondLevelCacheMock->expects($this->never())->method('get'); // when we add a value with the identifier to the two level cache, the second level // cache should not be asked because the value should allready be found in the first // level cache $this->twoLevelCache->set('foo', 'bar'); $value = $this->twoLevelCache->get('foo'); $this->assertSame($value, 'bar', 'Did not get expected value from two level cache'); }
/** * Actual function to generate the rootline and cache it * * @throws \RuntimeException * @return void */ protected function generateRootlineCache() { $page = $this->getRecordArray($this->pageUid); // If the current page is a mounted (according to the MP parameter) handle the mount-point if ($this->isMountedPage()) { $mountPoint = $this->getRecordArray($this->parsedMountPointParameters[$this->pageUid]); $page = $this->processMountedPage($page, $mountPoint); $parentUid = $mountPoint['pid']; // Anyhow after reaching the mount-point, we have to go up that rootline unset($this->parsedMountPointParameters[$this->pageUid]); } else { $parentUid = $page['pid']; } $cacheTags = array('pageId_' . $page['uid']); if ($parentUid > 0) { // Get rootline of (and including) parent page $mountPointParameter = !empty($this->parsedMountPointParameters) ? $this->mountPointParameter : ''; /** @var $rootline \TYPO3\CMS\Core\Utility\RootlineUtility */ $rootline = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Utility\RootlineUtility::class, $parentUid, $mountPointParameter, $this->pageContext); $rootline = $rootline->get(); // retrieve cache tags of parent rootline foreach ($rootline as $entry) { $cacheTags[] = 'pageId_' . $entry['uid']; if ($entry['uid'] == $this->pageUid) { throw new \RuntimeException('Circular connection in rootline for page with uid ' . $this->pageUid . ' found. Check your mountpoint configuration.', 1343464103); } } } else { $rootline = array(); } array_push($rootline, $page); krsort($rootline); static::$cache->set($this->cacheIdentifier, $rootline, $cacheTags); static::$localCache[$this->cacheIdentifier] = $rootline; }
/** * Returns banners for the given parameters if given Hmac validation succeeds * * @param string $categories * @param string $startingPoint * @param string $displayMode * @param int $currentPageUid * @param string $hmac * @return string */ public function getBannersAction($categories = '', $startingPoint = '', $displayMode = 'all', $currentPageUid = 0, $hmac = '') { $compareString = $currentPageUid . $categories . $startingPoint . $displayMode; if ($this->hashService->validateHmac($compareString, $hmac)) { /** @var \DERHANSEN\SfBanners\Domain\Model\BannerDemand $demand */ $demand = $this->objectManager->get('DERHANSEN\\SfBanners\\Domain\\Model\\BannerDemand'); $demand->setCategories($categories); $demand->setStartingPoint($startingPoint); $demand->setDisplayMode($displayMode); $demand->setCurrentPageUid($currentPageUid); /* Get banners */ $banners = $this->bannerRepository->findDemanded($demand); /* Update Impressions */ $this->bannerRepository->updateImpressions($banners); /* Collect identifier based on uids for all banners */ $ident = $GLOBALS['TSFE']->id . $GLOBALS['TSFE']->sys_language_uid; foreach ($banners as $banner) { $ident .= $banner->getUid(); } $ret = $this->cacheInstance->get(sha1($ident)); if ($ret === false || $ret === null) { $this->view->assign('banners', $banners); $this->view->assign('settings', $this->settings); $ret = $this->view->render(); // Save value in cache $this->cacheInstance->set(sha1($ident), $ret, array('sf_banners'), $this->settings['cacheLifetime']); } } else { $ret = LocalizationUtility::translate('wrong_hmac', 'SfBanners'); } return $ret; }
/** * Complete password reset * * @param string $hash Identification hash of a password reset token * @param string $password New password of the user * @param string $passwordRepeat Confirmation of the new password * @return void * * @validate $password NotEmpty * @validate $passwordRepeat NotEmpty */ public function completePasswordResetAction($hash, $password, $passwordRepeat) { $token = $this->tokenCache->get($hash); if ($token !== FALSE) { $user = $this->frontendUserRepository->findByIdentifier($token['uid']); if ($user !== NULL) { if ($this->hashService->validateHmac($user->getPassword(), $token['hmac'])) { $user->setPassword($this->passwordService->applyTransformations($password)); $this->frontendUserRepository->update($user); $this->tokenCache->remove($hash); if ($this->getSettingValue('passwordReset.loginOnSuccess')) { $this->authenticationService->authenticateUser($user); $this->addLocalizedFlashMessage('resetPassword.completed.login', NULL, FlashMessage::OK); } else { $this->addLocalizedFlashMessage('resetPassword.completed', NULL, FlashMessage::OK); } } else { $this->addLocalizedFlashMessage('resetPassword.failed.expired', NULL, FlashMessage::ERROR); } } else { $this->addLocalizedFlashMessage('resetPassword.failed.invalid', NULL, FlashMessage::ERROR); } } else { $this->addLocalizedFlashMessage('resetPassword.failed.expired', NULL, FlashMessage::ERROR); } $loginPageUid = $this->getSettingValue('login.page'); $this->redirect('showLoginForm', NULL, NULL, NULL, $loginPageUid); }
/** * Clear the class cache * * @return void */ public function clear() { $this->cacheInstance->flush(); if (isset($GLOBALS['BE_USER'])) { $GLOBALS['BE_USER']->writelog(3, 1, 0, 0, '[StaticInfoTables]: User %s has cleared the class cache', array($GLOBALS['BE_USER']->user['username'])); } }
/** * Register the given brush for deferred loading. * * @param AbstractBrush $brush * * @return void */ public function handle(AbstractBrush $brush) { $brushes = []; $aliases = []; if ($this->cache->has('brushes')) { $brushes = (array) $this->cache->get('brushes'); } if (isset($brushes[$brush->identifier])) { $aliases = (array) $brushes[$brush->identifier]; } $aliasKeys = array_flip($aliases); if (!isset($aliasKeys[$brush->alias])) { array_push($aliases, $brush->alias); } $brushes[$brush->identifier] = $aliases; $this->cache->set('brushes', $brushes); }
/** * @param array $params * @param FrontendInterface $frontend */ public function set($params, $frontend) { /* We're only intrested in the page cache */ if ($frontend->getIdentifier() !== 'cache_pages') { return; } $data = $params['variable']; $tags = $params['tags']; $lifetime = $params['lifetime']; $uri = GeneralUtility::getIndpEnv('TYPO3_REQUEST_URL'); $temp_content = isset($data['temp_content']) && $data['temp_content']; $tsfe = $this->getTypoScriptFrontendController(); $cachable = $temp_content === false && $tsfe->isStaticCacheble() && $tsfe->doWorkspacePreview() === false && strpos($uri, '?') === false && in_array('nginx_cache_ignore', $tags) === false; if ($cachable) { $this->getCacheManager()->getCache('nginx_cache')->set(md5($uri), $uri, $tags, $lifetime); } }
public function jsFooterInlineAction() { if (!$this->cache->has('brushes')) { return ''; } // arguments for the AddPageAssetListenerInterface implementation $this->request->setArgument('compress', false); $this->request->setArgument('forceOnTop', false); $this->view->assign('brushes', $this->cache->get('brushes')); }
public function geoJSONAction() { $geoJson = '{}'; if (is_numeric($uid = GeneralUtility::_GP('uid'))) { // Don't return anything, not even cached entry, if the map is not in the repository if (!is_null($map = $this->mapRepository->findByIdentifier($uid))) { if ($GLOBALS['TSFE']->sys_page->versioningPreview) { $geoJson = $this->geoJSONService->generateFeatureCollectionGeoJSON($map->getFeatures()); } else { if ($this->frontend->get($uid) == FALSE) { $geoJson = $this->geoJSONService->generateFeatureCollectionGeoJSON($map->getFeatures()); $this->frontend->set($uid, $geoJson); } else { $geoJson = $this->frontend->get($uid); } } } } return $geoJson; }
/** * cache resource * * @param $resource * @return void */ protected function cacheResource($resource) { if (!empty($resource)) { $cacheKey = $this->getCacheIdentifierForPath($resource['path']); if (!$this->cache->has($cacheKey)) { if (!$resource['is_dir']) { $this->cache->set($cacheKey, $resource); } } } }
/** * Checks if a cache entry is given for given versions and filter text and tries to load the data array from cache. * * @param array $versions All records uids etc. First key is table name, second key incremental integer. Records are associative arrays with uid and t3ver_oid fields. The pid of the online record is found as "livepid" the pid of the offline record is found in "wspid * @param string $filterTxt The given filter text from the grid. * @return boolean TRUE if cache entry was successfully fetched from cache and content put to $this->dataArray */ protected function getDataArrayFromCache(array $versions, $filterTxt) { $cacheEntry = FALSE; $hash = $this->calculateHash($versions, $filterTxt); $content = $this->workspacesCache->get($hash); if ($content !== FALSE) { $this->dataArray = $content; $cacheEntry = TRUE; } return $cacheEntry; }
/** * Flush data from cache table * * @return void */ public function flushCacheTable() { $this->cacheFrontend->flush(); }
/** * @param string $identifier * @param string $content * @return void */ protected function setToCache($identifier, $content) { $this->cache->set($identifier, $content); }
public function setCached($url, $content) { $this->cache->set($this->calculateCacheIdentifier($url), $content, array(), $this->seconds); return $this->isCached($url); }
/** * @return void */ public function flush() { self::$firstLevelCache[$this->cacheName] = array(); $this->secondLevelCache->flush(); }
/** * Sets a reference to the cache frontend which uses this backend * * @param \TYPO3\CMS\Core\Cache\Frontend\FrontendInterface $cache The frontend for this backend * @return void * @api */ public function setCache(\TYPO3\CMS\Core\Cache\Frontend\FrontendInterface $cache) { $this->cache = $cache; $this->cacheIdentifier = $this->cache->getIdentifier(); }
/** * Registers a cache so it can be retrieved at a later point. * * @param \TYPO3\CMS\Core\Cache\Frontend\FrontendInterface $cache The cache frontend to be registered * @return void * @throws \TYPO3\CMS\Core\Cache\Exception\DuplicateIdentifierException if a cache with the given identifier has already been registered. * @api */ public function registerCache(\TYPO3\CMS\Core\Cache\Frontend\FrontendInterface $cache) { $identifier = $cache->getIdentifier(); if (isset($this->caches[$identifier])) { throw new \TYPO3\CMS\Core\Cache\Exception\DuplicateIdentifierException('A cache with identifier "' . $identifier . '" has already been registered.', 1203698223); } $this->caches[$identifier] = $cache; }
public function flush() { $this->cacheInstance->flush(); }
/** * Returns a cache entry * * @param string $entryIdentifier Cache entry identifier * * @return mixed */ public function get($entryIdentifier) { return $this->cache->get($entryIdentifier); }
/** * Writes to cache. * * @param string $cacheIdentifier * @param ErrorHandlerInterface $errorHandler */ public function set($cacheIdentifier, ErrorHandlerInterface $errorHandler) { $tags = (array) $errorHandler->getCacheTags(); $data = json_encode(array('class' => get_class($errorHandler), 'data' => $errorHandler->getCachingData())); $this->cacheInstance->set($cacheIdentifier, $data, $tags); }
/** * */ public function flush() { $this->cache->flush(); }