/** * This method walks through the view configuration and applies * matching configurations in the order of their specifity score. * Possible options are currently the viewObjectName to specify * a different class that will be used to create the view and * an array of options that will be set on the view object. * * @param ActionRequest $request * @return array */ public function getViewConfiguration(ActionRequest $request) { $cacheIdentifier = $this->createCacheIdentifier($request); $viewConfiguration = $this->cache->get($cacheIdentifier); if ($viewConfiguration === false) { $configurations = $this->configurationManager->getConfiguration('Views'); $requestMatcher = new RequestMatcher($request); $context = new Context($requestMatcher); $viewConfiguration = []; $highestWeight = -1; foreach ($configurations as $order => $configuration) { $requestMatcher->resetWeight(); if (!isset($configuration['requestFilter'])) { $weight = $order; } else { $result = $this->eelEvaluator->evaluate($configuration['requestFilter'], $context); if ($result === false) { continue; } $weight = $requestMatcher->getWeight() + $order; } if ($weight > $highestWeight) { $viewConfiguration = $configuration; $highestWeight = $weight; } } $this->cache->set($cacheIdentifier, $viewConfiguration); } return $viewConfiguration; }
/** * Lifecycle method, called after all dependencies have been injected. * Here, the typeConverter array gets initialized. * * @return void */ public function initializeObject() { if ($this->cache->has('typeConverterMap')) { $this->typeConverters = $this->cache->get('typeConverterMap'); return; } $this->typeConverters = $this->prepareTypeConverterMap(); $this->cache->set('typeConverterMap', $this->typeConverters); }
/** * Initializes the locale service * * @return void */ public function initializeObject() { $this->configuration = new Configuration($this->settings['defaultLocale']); $this->configuration->setFallbackRule($this->settings['fallbackRule']); if ($this->cache->has('availableLocales')) { $this->localeCollection = $this->cache->get('availableLocales'); } else { $this->generateAvailableLocalesCollectionByScanningFilesystem(); $this->cache->set('availableLocales', $this->localeCollection); } }
/** * @Flow\Around("setting(Neos.Neos.typoScript.enableObjectTreeCache) && method(Neos\Neos\Domain\Service\TypoScriptService->getMergedTypoScriptObjectTree())") * @param JoinPointInterface $joinPoint The current join point * @return mixed */ public function cacheGetMergedTypoScriptObjectTree(JoinPointInterface $joinPoint) { $currentSiteNode = $joinPoint->getMethodArgument('startNode'); $cacheIdentifier = str_replace('.', '_', $currentSiteNode->getContext()->getCurrentSite()->getSiteResourcesPackageKey()); if ($this->typoScriptCache->has($cacheIdentifier)) { $typoScriptObjectTree = $this->typoScriptCache->get($cacheIdentifier); } else { $typoScriptObjectTree = $joinPoint->getAdviceChain()->proceed($joinPoint); $this->typoScriptCache->set($cacheIdentifier, $typoScriptObjectTree); } return $typoScriptObjectTree; }
/** * Save the found matches to the cache. * * @return void */ public function savePolicyCache() { $tags = ['TYPO3_Flow_Aop']; if (!$this->methodPermissionCache->has('methodPermission')) { $this->methodPermissionCache->set('methodPermission', $this->methodPermissions, $tags); } }
/** * @return integer The current cache version identifier */ public function getCacheVersion() { $version = $this->xliffToJsonTranslationsCache->get('ConfigurationVersion'); if ($version === false) { $version = time(); $this->xliffToJsonTranslationsCache->set('ConfigurationVersion', (string) $version); } return $version; }
/** * Returns all sessions which are tagged by the specified tag. * * @param string $tag A valid Cache Frontend tag * @return array A collection of Session objects or an empty array if tag did not match * @api */ public function getSessionsByTag($tag) { $taggedSessions = []; foreach ($this->metaDataCache->getByTag(Session::TAG_PREFIX . $tag) as $sessionIdentifier => $sessionInfo) { $session = new Session($sessionIdentifier, $sessionInfo['storageIdentifier'], $sessionInfo['lastActivityTimestamp'], $sessionInfo['tags']); $taggedSessions[] = $session; } return $taggedSessions; }
/** * When it's called, XML file is parsed (using parser set in $xmlParser) * or cache is loaded, if available. * * @return void */ public function initializeObject() { if ($this->cache->has(md5($this->sourcePath))) { $this->xmlParsedData = $this->cache->get(md5($this->sourcePath)); } else { $this->xmlParsedData = $this->xmlParser->getParsedData($this->sourcePath); $this->cache->set(md5($this->sourcePath), $this->xmlParsedData); } }
/** * When it's called, CLDR file is parsed or cache is loaded, if available. * * @return void */ public function initializeObject() { if ($this->cache->has($this->cacheKey)) { $this->parsedData = $this->cache->get($this->cacheKey); } else { $this->parsedData = $this->parseFiles($this->sourcePaths); $this->parsedData = $this->resolveAliases($this->parsedData, ''); $this->cache->set($this->cacheKey, $this->parsedData); } }
/** * Constructs the reader, loading parsed data from cache if available. * * @return void */ public function initializeObject() { if ($this->cache->has('rulesets') && $this->cache->has('rulesetsIndices')) { $this->rulesets = $this->cache->get('rulesets'); $this->rulesetsIndices = $this->cache->get('rulesetsIndices'); } else { $this->generateRulesets(); $this->cache->set('rulesets', $this->rulesets); $this->cache->set('rulesetsIndices', $this->rulesetsIndices); } }
/** * This checks if a given hash is known and still valid before returning the associated Token. * * If no valid Token is found for the hash, NULL is returned. * * @param $tokenHash * @return Token */ public function validateTokenHash($tokenHash) { $tokenData = $this->tokenCache->get($tokenHash); if ($tokenData === FALSE) { $this->logger->log(sprintf('Validation of token hash %s failed', $tokenHash), LOG_INFO); return NULL; } $this->tokenCache->remove($tokenHash); $this->logger->log(sprintf('Validated token hash %s for identifier %s', $tokenHash, $tokenData['identifier']), LOG_INFO); return new Token($tokenHash, $tokenData['identifier'], $this->getPreset($tokenData['presetName']), $tokenData['meta']); }
public function setUp() { $this->viewConfigurationManager = new ViewConfigurationManager(); // eel evaluator $eelEvaluator = new CompilingEvaluator(); $this->inject($this->viewConfigurationManager, 'eelEvaluator', $eelEvaluator); // a dummy configuration manager is prepared $this->mockConfigurationManager = $this->getMockBuilder(ConfigurationManager::class)->disableOriginalConstructor()->getMock(); $this->inject($this->viewConfigurationManager, 'configurationManager', $this->mockConfigurationManager); // caching is deactivated $this->mockCache = $this->getMockBuilder(VariableFrontend::class)->disableOriginalConstructor()->getMock(); $this->mockCache->expects($this->any())->method('get')->will($this->returnValue(false)); $this->inject($this->viewConfigurationManager, 'cache', $this->mockCache); // a dummy request is prepared $this->mockActionRequest = $this->getMockBuilder(ActionRequest::class)->disableOriginalConstructor()->getMock(); $this->mockActionRequest->expects($this->any())->method('getControllerPackageKey')->will($this->returnValue('Neos.Flow')); $this->mockActionRequest->expects($this->any())->method('getControllerSubpackageKey')->will($this->returnValue('')); $this->mockActionRequest->expects($this->any())->method('getControllerName')->will($this->returnValue('Standard')); $this->mockActionRequest->expects($this->any())->method('getControllerActionName')->will($this->returnValue('index')); $this->mockActionRequest->expects($this->any())->method('getFormat')->will($this->returnValue('html')); $this->mockActionRequest->expects($this->any())->method('getParentRequest')->will($this->returnValue(null)); }
/** * Builds proxy class code which weaves advices into the respective target classes. * * The object configurations provided by the Compiler are searched for possible aspect * annotations. If an aspect class is found, the pointcut expressions are parsed and * a new aspect with one or more advisors is added to the aspect registry of the AOP framework. * Finally all advices are woven into their target classes by generating proxy classes. * * In general, the command neos.flow:core:compile is responsible for compilation * and calls this method to do so. * * In order to distinguish between an emerged / changed possible target class and * a class which has been matched previously but just didn't have to be proxied, * the latter are kept track of by an "unproxiedClass-*" cache entry. * * @return void */ public function build() { $allAvailableClassNamesByPackage = $this->objectManager->getRegisteredClassNames(); $possibleTargetClassNames = $this->getProxyableClasses($allAvailableClassNamesByPackage); $actualAspectClassNames = $this->reflectionService->getClassNamesByAnnotation(Flow\Aspect::class); sort($possibleTargetClassNames); sort($actualAspectClassNames); $this->aspectContainers = $this->buildAspectContainers($actualAspectClassNames); $rebuildEverything = false; if ($this->objectConfigurationCache->has('allAspectClassesUpToDate') === false) { $rebuildEverything = true; $this->systemLogger->log('Aspects have been modified, therefore rebuilding all target classes.', LOG_INFO); $this->objectConfigurationCache->set('allAspectClassesUpToDate', true); } $possibleTargetClassNameIndex = new ClassNameIndex(); $possibleTargetClassNameIndex->setClassNames($possibleTargetClassNames); $targetClassNameCandidates = new ClassNameIndex(); foreach ($this->aspectContainers as $aspectContainer) { $targetClassNameCandidates->applyUnion($aspectContainer->reduceTargetClassNames($possibleTargetClassNameIndex)); } $targetClassNameCandidates->sort(); $treatedSubClasses = new ClassNameIndex(); foreach ($targetClassNameCandidates->getClassNames() as $targetClassName) { $isUnproxied = $this->objectConfigurationCache->has('unproxiedClass-' . str_replace('\\', '_', $targetClassName)); $hasCacheEntry = $this->compiler->hasCacheEntryForClass($targetClassName) || $isUnproxied; if ($rebuildEverything === true || $hasCacheEntry === false) { $proxyBuildResult = $this->buildProxyClass($targetClassName, $this->aspectContainers); if ($proxyBuildResult === false) { // In case the proxy was not build because there was nothing adviced, // it might be an advice in the parent and so we need to try to treat this class. $treatedSubClasses = $this->addBuildMethodsAndAdvicesCodeToClass($targetClassName, $treatedSubClasses); } $treatedSubClasses = $this->proxySubClassesOfClassToEnsureAdvices($targetClassName, $targetClassNameCandidates, $treatedSubClasses); if ($proxyBuildResult !== false) { if ($isUnproxied) { $this->objectConfigurationCache->remove('unproxiedClass-' . str_replace('\\', '_', $targetClassName)); } $this->systemLogger->log(sprintf('Built AOP proxy for class "%s".', $targetClassName), LOG_DEBUG); } else { $this->objectConfigurationCache->set('unproxiedClass-' . str_replace('\\', '_', $targetClassName), true); } } } }
/** * Get the size of a Flow PersistentResource that contains an image file. * * @param PersistentResource $resource * @return array width and height as keys * @throws ImageFileException */ public function getImageSize(PersistentResource $resource) { $cacheIdentifier = $resource->getCacheEntryIdentifier(); $imageSize = $this->imageSizeCache->get($cacheIdentifier); if ($imageSize !== false) { return $imageSize; } // TODO: Special handling for SVG should be refactored at a later point. if ($resource->getMediaType() === 'image/svg+xml') { $imageSize = ['width' => null, 'height' => null]; } else { try { $imagineImage = $this->imagineService->read($resource->getStream()); $sizeBox = $imagineImage->getSize(); $imageSize = array('width' => $sizeBox->getWidth(), 'height' => $sizeBox->getHeight()); } catch (\Exception $e) { throw new ImageFileException(sprintf('The given resource was not an image file your choosen driver can open. The original error was: %s', $e->getMessage()), 1336662898); } } $this->imageSizeCache->set($cacheIdentifier, $imageSize); return $imageSize; }
/** * Builds the objects array which contains information about the registered objects, * their scope, class, built method etc. * * @return array */ protected function buildObjectsArray() { $objects = []; foreach ($this->objectConfigurations as $objectConfiguration) { $objectName = $objectConfiguration->getObjectName(); $objects[$objectName] = ['l' => strtolower($objectName), 's' => $objectConfiguration->getScope(), 'p' => $objectConfiguration->getPackageKey()]; if ($objectConfiguration->getClassName() !== $objectName) { $objects[$objectName]['c'] = $objectConfiguration->getClassName(); } if ($objectConfiguration->getFactoryObjectName() !== '') { $objects[$objectName]['f'] = [$objectConfiguration->getFactoryObjectName(), $objectConfiguration->getFactoryMethodName()]; $objects[$objectName]['fa'] = []; $factoryMethodArguments = $objectConfiguration->getArguments(); if (count($factoryMethodArguments) > 0) { foreach ($factoryMethodArguments as $index => $argument) { $objects[$objectName]['fa'][$index] = ['t' => $argument->getType(), 'v' => $argument->getValue()]; } } } } $this->configurationCache->set('objects', $objects); return $objects; }
/** * @test * @requires extension igbinary */ public function getByTagUsesIgBinaryIfAvailable() { $tag = 'sometag'; $identifiers = ['one', 'two']; $entries = ['one' => 'one value', 'two' => 'two value']; $backend = $this->prepareDefaultBackend(); $backend->expects($this->once())->method('findIdentifiersByTag')->with($this->equalTo($tag))->will($this->returnValue($identifiers)); $backend->expects($this->exactly(2))->method('get')->will($this->onConsecutiveCalls(igbinary_serialize('one value'), igbinary_serialize('two value'))); $cache = new VariableFrontend('VariableFrontend', $backend); $cache->initializeObject(); $this->assertEquals($entries, $cache->getByTag($tag), 'Did not receive the expected entries'); }
/** * @test */ public function flushCachesResetsBothRoutingCaches() { $this->mockRouteCache->expects($this->once())->method('flush'); $this->mockResolveCache->expects($this->once())->method('flush'); $this->routerCachingService->flushCaches(); }
/** * @return boolean */ protected function hasFrozenCacheInProduction() { return $this->environment->getContext()->isProduction() && $this->reflectionDataRuntimeCache->getBackend()->isFrozen(); }
/** * Shutdowns the object, saving parsed format strings to the cache. * * @return void */ public function shutdownObject() { $this->cache->set('parsedFormats', $this->parsedFormats); $this->cache->set('parsedFormatsIndices', $this->parsedFormatsIndices); $this->cache->set('localizedLiterals', $this->localizedLiterals); }
/** * Creates a cache for testing * * @param string $name * @return VariableFrontend */ protected function createCache($name) { $backend = new FileBackend(new EnvironmentConfiguration('Session Testing', 'vfs://Foo/', PHP_MAXPATHLEN)); $cache = new VariableFrontend($name, $backend); $cache->initializeObject(); $backend->setCache($cache); $cache->flush(); return $cache; }
/** * Removes the session info cache entry for the specified session. * * Note that this function does only remove the "head" cache entry, not the * related data referred to by the storage identifier. * * @param string $sessionIdentifier * @return void */ protected function removeSessionMetaDataCacheEntry($sessionIdentifier) { $this->metaDataCache->remove($sessionIdentifier); }
/** * Flushes 'findMatchResults' and 'resolve' caches for the given $tag * * @param string $tag * @return void */ public function flushCachesByTag($tag) { $this->routeCache->flushByTag($tag); $this->resolveCache->flushByTag($tag); }