/**
* Stores the $matchResults in the cache
*
* @param Request $httpRequest
* @param array $matchResults
* @return void
*/
public function storeMatchResults(Request $httpRequest, array $matchResults)
{
if ($this->containsObject($matchResults)) {
return;
}
$this->routeCache->set($this->buildRouteCacheIdentifier($httpRequest), $matchResults, $this->extractUuids($matchResults));
}
/**
* 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 \TYPO3\Flow\Mvc\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);
$matchingConfigurations = array();
foreach ($configurations as $order => $configuration) {
$requestMatcher->resetWeight();
if (!isset($configuration['requestFilter'])) {
$matchingConfigurations[$order]['configuration'] = $configuration;
$matchingConfigurations[$order]['weight'] = $order;
} else {
$result = $this->eelEvaluator->evaluate($configuration['requestFilter'], $context);
if ($result === false) {
continue;
}
$matchingConfigurations[$order]['configuration'] = $configuration;
$matchingConfigurations[$order]['weight'] = $requestMatcher->getWeight() + $order;
}
}
usort($matchingConfigurations, function ($configuration1, $configuration2) {
return $configuration1['weight'] > $configuration2['weight'];
});
$viewConfiguration = array();
foreach ($matchingConfigurations as $key => $matchingConfiguration) {
$viewConfiguration = Arrays::arrayMergeRecursiveOverrule($viewConfiguration, $matchingConfiguration['configuration']);
}
$this->cache->set($cacheIdentifier, $viewConfiguration);
}
return $viewConfiguration;
}
/**
* Lifecycle method, called after all dependencies have been injected.
* Here, the typeConverter array gets initialized.
*
* @return void
* @throws Exception\DuplicateTypeConverterException
*/
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(TYPO3.Neos.typoScript.enableObjectTreeCache) && method(TYPO3\Neos\Domain\Service\TypoScriptService->getMergedTypoScriptObjectTree())")
* @param \TYPO3\Flow\Aop\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;
}
/**
* @param string $postalCode The zip code
* @param string $countryCode The two character ISO 3166-1 country code
* @return array|NULL The coordinates or NULL if none could be fetched
*/
public function fetchCoordinatesByPostalCode($postalCode, $countryCode)
{
$cacheIdentifier = $postalCode . '-' . $countryCode;
if (!isset($this->postalCodeCoordinates[$cacheIdentifier])) {
try {
$this->postalCodeCoordinates[$cacheIdentifier] = $this->geoCodingAdapter->fetchCoordinatesByPostalCode($postalCode, $countryCode);
$this->cache->set('postalCodeCoordinates', $this->postalCodeCoordinates);
} catch (NoSuchCoordinatesException $exception) {
return null;
}
}
return $this->postalCodeCoordinates[$cacheIdentifier];
}
/**
* Save the found matches to the cache.
*
* @return void
*/
public function savePolicyCache()
{
$tags = array('TYPO3_Flow_Aop');
if (!$this->methodPermissionCache->has('methodPermission')) {
$this->methodPermissionCache->set('methodPermission', $this->methodPermissions, $tags);
}
}
/**
* @Flow\Around("setting(Ttree.Embedly.logApiRequest) && within(Ttree\Embedly\Embedly) && method(public .*->(oembed|preview|objectify|extract|services)())")
* @param JoinPointInterface $joinPoint The current join point
* @return mixed
*/
public function getResponseFromCache(JoinPointInterface $joinPoint)
{
$proxy = $joinPoint->getProxy();
$key = ObjectAccess::getProperty($proxy, 'key');
$params = $joinPoint->getMethodArgument('params');
$cacheKey = md5($joinPoint->getClassName() . $joinPoint->getMethodName() . $key . json_encode($params));
if ($this->responseCache->has($cacheKey)) {
$this->systemLogger->log(sprintf(' cache hit Embedly::%s', $joinPoint->getMethodName()), LOG_DEBUG);
return $this->responseCache->get($cacheKey);
} else {
$this->systemLogger->log(sprintf(' cache miss Embedly::%s', $joinPoint->getMethodName()), LOG_DEBUG);
}
$response = $joinPoint->getAdviceChain()->proceed($joinPoint);
$this->responseCache->set($cacheKey, $response);
return $response;
}
/**
* @param Locale $locale
* @param Language $language
* @return string
*/
public function getLanguageLocalizedName(Locale $locale, Language $language)
{
$cacheIdentifier = 'language-labels-' . $locale->getLanguage();
$labelsFromCache = $this->languageCache->get($cacheIdentifier);
if ($labelsFromCache) {
return $labelsFromCache[$language->getKey()];
}
try {
$raw = $this->cldrRepository->getModelForLocale($locale)->getRawArray('localeDisplayNames/languages');
} catch (\Exception $e) {
return 'Problem reading data for ' . $language->getKey();
}
$languages = $this->getLanguages();
$labels = array();
/** @var Language $currentLanguage */
foreach ($languages as $currentLanguage) {
try {
$key = 'language[@type="' . $currentLanguage->getKey() . '"]';
if (is_array($raw)) {
if (array_key_exists($key, $raw)) {
$labels[$currentLanguage->getKey()] = $raw[$key];
} else {
$labels[$currentLanguage->getKey()] = $currentLanguage->getName();
}
} else {
$labels[$currentLanguage->getKey()] = 'Nothing found for ' . $currentLanguage->getKey();
}
} catch (\Exception $e) {
// not found
// $labels[$key] = 'Nothing found for ' . $language->getKey();
}
}
$this->languageCache->set($cacheIdentifier, $labels);
return $labels[$language->getKey()];
}
/**
* Return the json array for a given locale, sourceCatalog, xliffPath and package.
* The json will be cached.
*
* @param Locale $locale The locale
* @throws \TYPO3\Flow\I18n\Exception
* @return \TYPO3\Flow\Error\Result
*/
public function getCachedJson(Locale $locale)
{
$cacheIdentifier = md5($locale);
if ($this->xliffToJsonTranslationsCache->has($cacheIdentifier)) {
$json = $this->xliffToJsonTranslationsCache->get($cacheIdentifier);
} else {
$labels = [];
$localeChain = $this->localizationService->getLocaleChain($locale);
foreach ($this->packagesRegisteredForAutoInclusion as $packageKey => $sourcesToBeIncluded) {
if (!is_array($sourcesToBeIncluded)) {
continue;
}
$translationBasePath = Files::concatenatePaths([$this->packageManager->getPackage($packageKey)->getResourcesPath(), $this->xliffBasePath]);
// We merge labels in the chain from the worst choice to best choice
foreach (array_reverse($localeChain) as $allowedLocale) {
$localeSourcePath = Files::getNormalizedPath(Files::concatenatePaths([$translationBasePath, $allowedLocale]));
foreach ($sourcesToBeIncluded as $sourceName) {
foreach (glob($localeSourcePath . $sourceName . '.xlf') as $xliffPathAndFilename) {
$xliffPathInfo = pathinfo($xliffPathAndFilename);
$sourceName = str_replace($localeSourcePath, '', $xliffPathInfo['dirname'] . '/' . $xliffPathInfo['filename']);
$labels = Arrays::arrayMergeRecursiveOverrule($labels, $this->parseXliffToArray($xliffPathAndFilename, $packageKey, $sourceName));
}
}
}
}
$json = json_encode($labels);
$this->xliffToJsonTranslationsCache->set($cacheIdentifier, $json);
}
return $json;
}
/**
* Stores the $matchResults in the cache
*
* @param Request $httpRequest
* @param array $matchResults
* @return void
*/
public function storeMatchResults(Request $httpRequest, array $matchResults)
{
if ($this->containsObject($matchResults)) {
return;
}
$tags = $this->generateRouteTags($httpRequest->getRelativePath(), $matchResults);
$this->routeCache->set($this->buildRouteCacheIdentifier($httpRequest), $matchResults, $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;
}
/**
* Writes the cache entry containing information about the session, such as the
* last activity time and the storage identifier.
*
* This function does not write the whole session _data_ into the storage cache,
* but only the "head" cache entry containing meta information.
*
* The session cache entry is also tagged with "session", the session identifier
* and any custom tags of this session, prefixed with TAG_PREFIX.
*
* @return void
*/
protected function writeSessionMetaDataCacheEntry()
{
$sessionInfo = array('lastActivityTimestamp' => $this->lastActivityTimestamp, 'storageIdentifier' => $this->storageIdentifier, 'tags' => $this->tags);
$tagsForCacheEntry = array_map(function ($tag) {
return Session::TAG_PREFIX . $tag;
}, $this->tags);
$tagsForCacheEntry[] = $this->sessionIdentifier;
$this->metaDataCache->set($this->sessionIdentifier, $sessionInfo, $tagsForCacheEntry, 0);
}
/**
* 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);
}
}
/**
* Save the found matches to the cache.
*
* @return void
*/
public function savePolicyCache()
{
$tags = array('TYPO3_Flow_Aop');
if (!$this->cache->has('acls')) {
$this->cache->set('acls', $this->acls, $tags);
}
if (!$this->cache->has('entityResourcesConstraints')) {
$this->cache->set('entityResourcesConstraints', $this->entityResourcesConstraints);
}
}
/**
* 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);
}
}
/**
* @param Task $task
* @param string $type
*/
public function update(Task $task, $type)
{
switch ($type) {
case TaskInterface::TYPE_DYNAMIC:
$cacheKey = md5($task->getImplementation());
$this->dynamicTaskLastExecutionCache->set($cacheKey, $task->getLastExecution());
break;
case TaskInterface::TYPE_PERSISTED:
$this->taskRepository->update($task);
break;
}
}
/**
* Set updated reflection data to caches.
*/
protected function updateReflectionData()
{
$this->log(sprintf('Found %s classes whose reflection data was not cached previously.', count($this->updatedReflectionData)), LOG_DEBUG);
foreach (array_keys($this->updatedReflectionData) as $className) {
$this->statusCache->set($this->produceCacheIdentifierFromClassName($className), '');
}
$data = [];
$propertyNames = ['classReflectionData', 'classSchemata', 'annotatedClasses', 'classesByMethodAnnotations'];
foreach ($propertyNames as $propertyName) {
$data[$propertyName] = $this->{$propertyName};
}
$this->reflectionDataCompiletimeCache->set('ReflectionData', $data);
}
/**
* Exports the internal reflection data into the ReflectionData cache
*
* This method is triggered by a signal which is connected to the bootstrap's
* shutdown sequence.
*
* If the reflection data has previously been loaded from the runtime cache,
* saving it is omitted as changes are not expected.
*
* In Production context the whole cache is written at once and then frozen in
* order to be consistent. Frozen cache data in Development is only produced for
* classes contained in frozen packages.
*
* @return void
* @throws \TYPO3\Flow\Reflection\Exception if no cache has been injected
*/
public function saveToCache()
{
if (!$this->initialized) {
$this->initialize();
}
if ($this->loadFromClassSchemaRuntimeCache === TRUE) {
return;
}
if (!$this->reflectionDataCompiletimeCache instanceof FrontendInterface) {
throw new Exception('A cache must be injected before initializing the Reflection Service.', 1232044697);
}
if (count($this->updatedReflectionData) > 0) {
$this->log(sprintf('Found %s classes whose reflection data was not cached previously.', count($this->updatedReflectionData)), LOG_DEBUG);
foreach (array_keys($this->updatedReflectionData) as $className) {
$this->statusCache->set(str_replace('\\', '_', $className), '');
}
$data = array();
$propertyNames = array('classReflectionData', 'classSchemata', 'annotatedClasses', 'classesByMethodAnnotations');
foreach ($propertyNames as $propertyName) {
$data[$propertyName] = $this->{$propertyName};
}
$this->reflectionDataCompiletimeCache->set('ReflectionData', $data);
}
if ($this->context->isProduction()) {
$this->reflectionDataRuntimeCache->flush();
$classNames = array();
foreach ($this->classReflectionData as $className => $reflectionData) {
$classNames[$className] = TRUE;
$this->reflectionDataRuntimeCache->set(str_replace('\\', '_', $className), $reflectionData);
if (isset($this->classSchemata[$className])) {
$this->classSchemataRuntimeCache->set(str_replace('\\', '_', $className), $this->classSchemata[$className]);
}
}
$this->reflectionDataRuntimeCache->set('__classNames', $classNames);
$this->reflectionDataRuntimeCache->set('__annotatedClasses', $this->annotatedClasses);
$this->reflectionDataRuntimeCache->getBackend()->freeze();
$this->classSchemataRuntimeCache->getBackend()->freeze();
$this->log(sprintf('Built and froze reflection runtime caches (%s classes).', count($this->classReflectionData)), LOG_INFO);
} elseif ($this->context->isDevelopment()) {
foreach (array_keys($this->packageManager->getFrozenPackages()) as $packageKey) {
$pathAndFilename = $this->getPrecompiledReflectionStoragePath() . $packageKey . '.dat';
if (!file_exists($pathAndFilename)) {
$this->log(sprintf('Rebuilding precompiled reflection data for frozen package %s.', $packageKey), LOG_INFO);
$this->freezePackageReflection($packageKey);
}
}
}
}
/**
* @param string $value
* @throws Exception
* @throws \TYPO3\Flow\Resource\Exception
* @throws \TYPO3\Flow\Utility\Exception
*/
protected function initializeValue($value)
{
if (!is_array($value)) {
throw new Exception('Value must be an array, with source URI (sourceUri) and filename (filename)', 1425981082);
}
if (!isset($value['sourceUri'])) {
throw new Exception('Missing source URI', 1425981083);
}
$sourceUri = trim($value['sourceUri']);
if (!isset($value['filename'])) {
throw new Exception('Missing filename URI', 1425981084);
}
$filename = trim($value['filename']);
$overrideFilename = isset($value['overrideFilename']) ? trim($value['overrideFilename']) : $filename;
if (!isset($this->options['downloadDirectory'])) {
throw new Exception('Missing download directory data type option', 1425981085);
}
Files::createDirectoryRecursively($this->options['downloadDirectory']);
$temporaryFileAndPathname = trim($this->options['downloadDirectory'] . $filename);
$this->download($sourceUri, $temporaryFileAndPathname);
$sha1Hash = sha1_file($temporaryFileAndPathname);
# Try to add file extenstion if missing
if (!$this->downloadCache->has($sha1Hash)) {
$fileExtension = pathinfo($temporaryFileAndPathname, PATHINFO_EXTENSION);
if (trim($fileExtension) === '') {
$mimeTypeGuesser = new MimeTypeGuesser();
$mimeType = $mimeTypeGuesser->guess($temporaryFileAndPathname);
$this->logger->log(sprintf('Try to guess mime type for "%s" (%s), result: %s', $sourceUri, $filename, $mimeType), LOG_DEBUG);
$fileExtension = MediaTypes::getFilenameExtensionFromMediaType($mimeType);
if ($fileExtension !== '') {
$oldTemporaryDestination = $temporaryFileAndPathname;
$temporaryDestination = $temporaryFileAndPathname . '.' . $fileExtension;
copy($oldTemporaryDestination, $temporaryDestination);
$this->logger->log(sprintf('Rename "%s" to "%s"', $oldTemporaryDestination, $temporaryDestination), LOG_DEBUG);
}
}
}
$resource = $this->resourceManager->getResourceBySha1($sha1Hash);
if ($resource === NULL) {
$resource = $this->resourceManager->importResource($temporaryFileAndPathname);
if ($filename !== $overrideFilename) {
$resource->setFilename($overrideFilename);
}
}
$this->temporaryFileAndPathname = $temporaryFileAndPathname;
$this->downloadCache->set($sha1Hash, ['sha1Hash' => $sha1Hash, 'filename' => $filename, 'sourceUri' => $sourceUri, 'temporaryFileAndPathname' => $temporaryFileAndPathname]);
$this->value = $resource;
}
/**
* 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 typo3.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);
}
}
}
}
/**
* @param NodeInterface $node
* @return void
*/
public function refreshCacheIfNecessary(NodeInterface $node)
{
if ($node->getNodeType()->isOfType('Nezaniel.SystemNodes:SystemNode')) {
$currentPath = [];
$recursiveIterator = function (array $items) use(&$recursiveIterator, &$currentPath, $node) {
foreach ($items as $key => $entry) {
$currentPath[] = $key;
if (is_array($entry)) {
$recursiveIterator($entry);
} elseif ($entry === $node->getIdentifier()) {
$this->systemNodeIdentifiers = Arrays::unsetValueByPath($this->systemNodeIdentifiers, $currentPath);
}
array_pop($currentPath);
}
};
$recursiveIterator($this->systemNodeIdentifiers);
$this->initializeSystemNode($node);
$this->cache->set('systemNodeIdentifiers', $this->systemNodeIdentifiers);
}
}
/**
* Get the size of a Flow Resource object that contains an image file.
*
* @param FlowResource $resource
* @return array width and height as keys
* @throws ImageFileException
*/
public function getImageSize(FlowResource $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 = array();
foreach ($this->objectConfigurations as $objectConfiguration) {
$objectName = $objectConfiguration->getObjectName();
$objects[$objectName] = array('l' => strtolower($objectName), 's' => $objectConfiguration->getScope(), 'p' => $objectConfiguration->getPackageKey());
if ($objectConfiguration->getClassName() !== $objectName) {
$objects[$objectName]['c'] = $objectConfiguration->getClassName();
}
if ($objectConfiguration->getFactoryObjectName() !== '') {
$objects[$objectName]['f'] = array($objectConfiguration->getFactoryObjectName(), $objectConfiguration->getFactoryMethodName());
$objects[$objectName]['fa'] = array();
$factoryMethodArguments = $objectConfiguration->getArguments();
if (count($factoryMethodArguments) > 0) {
foreach ($factoryMethodArguments as $index => $argument) {
$objects[$objectName]['fa'][$index] = array('t' => $argument->getType(), 'v' => $argument->getValue());
}
}
}
}
$this->configurationCache->set('objects', $objects);
return $objects;
}
/**
* 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 typo3.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('TYPO3\\Flow\\Annotations\\Aspect');
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();
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) {
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);
}
}
}
}
/**
* @param string $cacheKey
* @param mixed $value
* @param array $tags
*/
protected function setItem($cacheKey, $value, $tags = array())
{
$this->objectCache[$cacheKey] = $value;
$this->apiCache->set($cacheKey, $value, $tags);
}
/**
* 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);
}
/**
* @param string $importerClassName
* @param string $externalIdentifier
* @param NodeInterface $node
*/
public function set($importerClassName, $externalIdentifier, NodeInterface $node)
{
$processedNode = ProcessedNodeDefinition::createFromNode($externalIdentifier, $node);
$entryIdentifier = $this->getEntryIdentifier($importerClassName, $externalIdentifier);
$this->cache->set($entryIdentifier, $processedNode);
}
/**
* Assert that one step for a badge assertion was successful and store a time-limited proof on the server
*
* @param BadgeClass $badgeClass
* @param string $stepIdentifier A (fixed) identifier for the assertion step
* @return AssertionStep
*/
public function assertStep(BadgeClass $badgeClass, $stepIdentifier)
{
$assertionStep = new AssertionStep($badgeClass, $stepIdentifier);
$this->assertionStepStore->set($assertionStep->getToken(), $assertionStep);
return $assertionStep;
}