/**
* 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;
}
/**
* Gets the authentication provider configuration needed
*
* @return void
*/
public function initializeObject()
{
$settings = $this->configurationManager->getConfiguration(\Neos\Flow\Configuration\ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.Flow');
if (isset($settings['security']['authentication']['providers']['Typo3SetupProvider']['providerOptions']['keyName'])) {
$this->keyName = $settings['security']['authentication']['providers']['Typo3SetupProvider']['providerOptions']['keyName'];
}
}
/**
* Prepares $this->nodeTypeManager with a fresh instance with all mocks and makes the given fixture data available as NodeTypes configuration
*
* @param array $nodeTypesFixtureData
*/
protected function prepareNodeTypeManager(array $nodeTypesFixtureData)
{
$this->nodeTypeManager = new NodeTypeManager();
$this->mockConfigurationManager = $this->getMockBuilder(ConfigurationManager::class)->disableOriginalConstructor()->getMock();
$mockCache = $this->getMockBuilder(StringFrontend::class)->disableOriginalConstructor()->getMock();
$mockCache->expects($this->any())->method('get')->willReturn(null);
$this->inject($this->nodeTypeManager, 'fullConfigurationCache', $mockCache);
$this->mockConfigurationManager->expects($this->any())->method('getConfiguration')->with('NodeTypes')->will($this->returnValue($nodeTypesFixtureData));
$this->inject($this->nodeTypeManager, 'configurationManager', $this->mockConfigurationManager);
}
/**
* @test
*/
public function getViewConfigurationUsedFilterConfigurationWithHigherWeight()
{
$matchingConfigurationOne = ['requestFilter' => 'isPackage("Neos.Flow")', 'options' => 'a value'];
$matchingConfigurationTwo = ['requestFilter' => 'isPackage("Neos.Flow") && isFormat("html")', 'options' => 'a value with higher weight'];
$notMatchingConfiguration = ['requestFilter' => 'isPackage("Vendor.Package")', 'options' => 'another value'];
$viewConfigurations = [$notMatchingConfiguration, $matchingConfigurationOne, $matchingConfigurationTwo];
$this->mockConfigurationManager->expects($this->any())->method('getConfiguration')->with('Views')->will($this->returnValue($viewConfigurations));
$calculatedConfiguration = $this->viewConfigurationManager->getViewConfiguration($this->mockActionRequest);
$this->assertEquals($calculatedConfiguration, $matchingConfigurationTwo);
}
public function setUp()
{
$this->policyService = new PolicyService();
$this->mockConfigurationManager = $this->getMockBuilder(ConfigurationManager::class)->disableOriginalConstructor()->getMock();
$this->mockConfigurationManager->expects($this->any())->method('getConfiguration')->with(ConfigurationManager::CONFIGURATION_TYPE_POLICY)->will($this->returnCallback(function () {
return $this->mockPolicyConfiguration;
}));
$this->inject($this->policyService, 'configurationManager', $this->mockConfigurationManager);
$this->mockObjectManager = $this->getMockBuilder(ObjectManager::class)->disableOriginalConstructor()->getMock();
$this->inject($this->policyService, 'objectManager', $this->mockObjectManager);
$this->mockPrivilege = $this->getAccessibleMock(AbstractPrivilege::class, ['matchesSubject'], [], '', false);
}
/**
* @param string $type
* @return void
*/
public function indexAction($type = 'Settings')
{
$availableConfigurationTypes = $this->configurationManager->getAvailableConfigurationTypes();
$this->view->assignMultiple(array('type' => $type, 'availableConfigurationTypes' => $availableConfigurationTypes));
if (in_array($type, $availableConfigurationTypes)) {
$this->view->assign('configuration', $this->configurationManager->getConfiguration($type));
try {
$this->view->assign('validationResult', $this->configurationSchemaValidator->validate($type));
} catch (SchemaValidationException $exception) {
$this->addFlashMessage(htmlspecialchars($exception->getMessage()), 'An error occurred during validation of the configuration.', Message::SEVERITY_ERROR, array(), 1412373972);
}
} else {
$this->addFlashMessage('Configuration type not found.', '', Message::SEVERITY_ERROR, array(), 1412373998);
}
}
/**
* Returns a fresh or existing instance of the object specified by $objectName.
*
* This specialized get() method is able to do setter injection for properties
* defined in the object configuration of the specified object.
*
* @param string $objectName The name of the object to return an instance of
* @return object The object instance
* @throws \Neos\Flow\ObjectManagement\Exception\CannotBuildObjectException
* @throws \Neos\Flow\ObjectManagement\Exception\UnresolvedDependenciesException
* @throws \Neos\Flow\ObjectManagement\Exception\UnknownObjectException
*/
public function get($objectName)
{
if (isset($this->objects[$objectName]['i'])) {
return $this->objects[$objectName]['i'];
}
if (isset($this->objectConfigurations[$objectName]) && count($this->objectConfigurations[$objectName]->getArguments()) > 0) {
throw new Exception\CannotBuildObjectException('Cannot build object "' . $objectName . '" because constructor injection is not available in the compile time Object Manager. Refactor your code to use setter injection instead. Configuration source: ' . $this->objectConfigurations[$objectName]->getConfigurationSourceHint() . '. Build stack: ' . implode(', ', $this->objectNameBuildStack), 1297090026);
}
if (!isset($this->objects[$objectName])) {
throw new Exception\UnknownObjectException('Cannot build object "' . $objectName . '" because it is unknown to the compile time Object Manager.', 1301477694);
}
if ($this->objects[$objectName]['s'] !== Configuration::SCOPE_SINGLETON) {
throw new Exception\CannotBuildObjectException('Cannot build object "' . $objectName . '" because the get() method in the compile time Object Manager only supports singletons.', 1297090027);
}
$this->objectNameBuildStack[] = $objectName;
$object = parent::get($objectName);
/** @var Configuration $objectConfiguration */
$objectConfiguration = $this->objectConfigurations[$objectName];
/** @var Property $property */
foreach ($objectConfiguration->getProperties() as $propertyName => $property) {
if ($property->getAutowiring() !== Configuration::AUTOWIRING_MODE_ON) {
continue;
}
switch ($property->getType()) {
case Property::PROPERTY_TYPES_STRAIGHTVALUE:
$value = $property->getValue();
break;
case Property::PROPERTY_TYPES_CONFIGURATION:
$propertyValue = $property->getValue();
$value = $this->configurationManager->getConfiguration($propertyValue['type'], $propertyValue['path']);
break;
case Property::PROPERTY_TYPES_OBJECT:
$propertyObjectName = $property->getValue();
if (!is_string($propertyObjectName)) {
throw new Exception\CannotBuildObjectException('The object definition of "' . $objectName . '::' . $propertyName . '" is too complex for the compile time Object Manager. You can only use plain object names, not factories and the like. Check configuration in ' . $this->objectConfigurations[$objectName]->getConfigurationSourceHint() . ' and objects which depend on ' . $objectName . '.', 1297099659);
}
$value = $this->get($propertyObjectName);
break;
default:
throw new Exception\CannotBuildObjectException('Invalid property type.', 1297090029);
}
if (method_exists($object, $setterMethodName = 'inject' . ucfirst($propertyName))) {
$object->{$setterMethodName}($value);
} elseif (method_exists($object, $setterMethodName = 'set' . ucfirst($propertyName))) {
$object->{$setterMethodName}($value);
} else {
throw new Exception\UnresolvedDependenciesException('Could not inject configured property "' . $propertyName . '" into "' . $objectName . '" because no injection method exists, but for compile time use this is required. Configuration source: ' . $this->objectConfigurations[$objectName]->getConfigurationSourceHint() . '.', 1297110953);
}
}
$initializationLifecycleMethodName = $this->objectConfigurations[$objectName]->getLifecycleInitializationMethodName();
if (method_exists($object, $initializationLifecycleMethodName)) {
$object->{$initializationLifecycleMethodName}();
}
$shutdownLifecycleMethodName = $this->objectConfigurations[$objectName]->getLifecycleShutdownMethodName();
if (method_exists($object, $shutdownLifecycleMethodName)) {
$this->shutdownObjects[$object] = $shutdownLifecycleMethodName;
}
array_pop($this->objectNameBuildStack);
return $object;
}
/**
* @test
*/
public function flushConfigurationCachesByChangedFilesFlushesConfigurationCache()
{
$this->registerCache('Flow_Object_Classes');
$this->registerCache('Flow_Object_Configuration');
$this->mockConfigurationManager->expects($this->once())->method('flushConfigurationCache');
$this->cacheManager->flushSystemCachesByChangedFiles('Flow_ConfigurationFiles', []);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
//
// create a mock packageManager that only returns the the packages that contain schema files
//
$schemaPackages = [];
$configurationPackages = [];
// get all packages and select the ones we want to test
$temporaryPackageManager = $this->objectManager->get(PackageManagerInterface::class);
foreach ($temporaryPackageManager->getActivePackages() as $package) {
if (in_array($package->getPackageKey(), $this->getSchemaPackageKeys())) {
$schemaPackages[$package->getPackageKey()] = $package;
}
if (in_array($package->getPackageKey(), $this->getConfigurationPackageKeys())) {
$configurationPackages[$package->getPackageKey()] = $package;
}
}
$this->mockPackageManager = $this->createMock(PackageManager::class);
$this->mockPackageManager->expects($this->any())->method('getActivePackages')->will($this->returnValue($schemaPackages));
//
// create mock configurationManager and store the original one
//
$this->originalConfigurationManager = $this->objectManager->get(ConfigurationManager::class);
$yamlConfigurationSource = $this->objectManager->get(\Neos\Flow\Tests\Functional\Configuration\Fixtures\RootDirectoryIgnoringYamlSource::class);
$this->mockConfigurationManager = clone $this->originalConfigurationManager;
$this->mockConfigurationManager->setPackages($configurationPackages);
$this->inject($this->mockConfigurationManager, 'configurationSource', $yamlConfigurationSource);
$this->objectManager->setInstance(ConfigurationManager::class, $this->mockConfigurationManager);
//
// create the configurationSchemaValidator
//
$this->configurationSchemaValidator = $this->objectManager->get(ConfigurationSchemaValidator::class);
$this->inject($this->configurationSchemaValidator, 'configurationManager', $this->mockConfigurationManager);
}
/**
* Parses the given configuration path expression and sets $this->actualSettingValue
* and $this->condition accordingly
*
* @param string $settingComparisonExpression The configuration expression (path + optional condition)
* @return void
* @throws InvalidPointcutExpressionException
*/
protected function parseConfigurationOptionPath($settingComparisonExpression)
{
$settingComparisonExpression = preg_split(self::PATTERN_SPLITBYEQUALSIGN, $settingComparisonExpression);
if (isset($settingComparisonExpression[1])) {
$matches = [];
preg_match(self::PATTERN_MATCHVALUEINQUOTES, $settingComparisonExpression[1], $matches);
if (isset($matches['SingleQuotedString']) && $matches['SingleQuotedString'] !== '') {
$this->condition = $matches['SingleQuotedString'];
} elseif (isset($matches['DoubleQuotedString']) && $matches['DoubleQuotedString'] !== '') {
$this->condition = $matches['DoubleQuotedString'];
} else {
throw new InvalidPointcutExpressionException('The given condition has a syntax error (Make sure to set quotes correctly). Got: "' . $settingComparisonExpression[1] . '"', 1230047529);
}
}
$configurationKeys = preg_split('/\\./', $settingComparisonExpression[0]);
if (count($configurationKeys) > 0) {
$settingPackageKey = array_shift($configurationKeys);
$settingValue = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $settingPackageKey);
foreach ($configurationKeys as $currentKey) {
if (!isset($settingValue[$currentKey])) {
throw new InvalidPointcutExpressionException('The given configuration path in the pointcut designator "setting" did not exist. Got: "' . $settingComparisonExpression[0] . '"', 1230035614);
}
$settingValue = $settingValue[$currentKey];
}
$this->actualSettingValue = $settingValue;
}
}
/**
* Flushes caches as needed if settings, routes or policies have changed
*
* @param array $changedFiles A list of full paths to changed files
* @return void
* @see flushSystemCachesByChangedFiles()
*/
protected function flushConfigurationCachesByChangedFiles(array $changedFiles)
{
$aopProxyClassRebuildIsNeeded = false;
$aopProxyClassInfluencers = '/(?:Policy|Objects|Settings)(?:\\..*)*\\.yaml/';
$objectClassesCache = $this->getCache('Flow_Object_Classes');
$objectConfigurationCache = $this->getCache('Flow_Object_Configuration');
$caches = ['/Policy\\.yaml/' => ['Flow_Security_Authorization_Privilege_Method', 'Flow_Persistence_Doctrine', 'Flow_Persistence_Doctrine_Results', 'Flow_Aop_RuntimeExpressions'], '/Routes([^\\/]*)\\.yaml/' => ['Flow_Mvc_Routing_Route', 'Flow_Mvc_Routing_Resolve'], '/Views\\.yaml/' => ['Flow_Mvc_ViewConfigurations']];
$cachesToFlush = [];
foreach (array_keys($changedFiles) as $pathAndFilename) {
foreach ($caches as $cacheFilePattern => $cacheNames) {
if (preg_match($aopProxyClassInfluencers, $pathAndFilename) === 1) {
$aopProxyClassRebuildIsNeeded = true;
}
if (preg_match($cacheFilePattern, $pathAndFilename) !== 1) {
continue;
}
foreach ($caches[$cacheFilePattern] as $cacheName) {
$cachesToFlush[$cacheName] = $cacheFilePattern;
}
}
}
foreach ($cachesToFlush as $cacheName => $cacheFilePattern) {
$this->systemLogger->log(sprintf('A configuration file matching the pattern "%s" has been changed, flushing related cache "%s"', $cacheFilePattern, $cacheName), LOG_INFO);
$this->getCache($cacheName)->flush();
}
$this->systemLogger->log('A configuration file has been changed, flushing compiled configuration cache', LOG_INFO);
$this->configurationManager->flushConfigurationCache();
if ($aopProxyClassRebuildIsNeeded) {
$this->systemLogger->log('The configuration has changed, triggering an AOP proxy class rebuild.', LOG_INFO);
$objectConfigurationCache->remove('allAspectClassesUpToDate');
$objectConfigurationCache->remove('allCompiledCodeUpToDate');
$objectClassesCache->flush();
}
}
/**
* Validate a single configuration type
*
* @param string $configurationType the configuration typr to validate
* @param string $path configuration path to validate, or NULL.
* @param array $loadedSchemaFiles will be filled with a list of loaded schema files
* @return \Neos\Error\Messages\Result
* @throws Exception\SchemaValidationException
*/
protected function validateSingleType($configurationType, $path, &$loadedSchemaFiles)
{
$availableConfigurationTypes = $this->configurationManager->getAvailableConfigurationTypes();
if (in_array($configurationType, $availableConfigurationTypes) === false) {
throw new Exception\SchemaValidationException('The configuration type "' . $configurationType . '" was not found. Only the following configuration types are supported: "' . implode('", "', $availableConfigurationTypes) . '"', 1364984886);
}
$configuration = $this->configurationManager->getConfiguration($configurationType);
// find schema files for the given type and path
$schemaFileInfos = [];
$activePackages = $this->packageManager->getActivePackages();
foreach ($activePackages as $package) {
$packageKey = $package->getPackageKey();
$packageSchemaPath = Files::concatenatePaths([$package->getResourcesPath(), 'Private/Schema']);
if (is_dir($packageSchemaPath)) {
foreach (Files::getRecursiveDirectoryGenerator($packageSchemaPath, '.schema.yaml') as $schemaFile) {
$schemaName = substr($schemaFile, strlen($packageSchemaPath) + 1, -strlen('.schema.yaml'));
$schemaNameParts = explode('.', str_replace('/', '.', $schemaName), 2);
$schemaType = $schemaNameParts[0];
$schemaPath = isset($schemaNameParts[1]) ? $schemaNameParts[1] : null;
if ($schemaType === $configurationType && ($path === null || strpos($schemaPath, $path) === 0)) {
$schemaFileInfos[] = ['file' => $schemaFile, 'name' => $schemaName, 'path' => $schemaPath, 'packageKey' => $packageKey];
}
}
}
}
if (count($schemaFileInfos) === 0) {
throw new Exception\SchemaValidationException('No schema files found for configuration type "' . $configurationType . '"' . ($path !== null ? ' and path "' . $path . '".' : '.'), 1364985056);
}
$result = new Result();
foreach ($schemaFileInfos as $schemaFileInfo) {
$loadedSchemaFiles[] = $schemaFileInfo['file'];
if ($schemaFileInfo['path'] !== null) {
$data = Arrays::getValueByPath($configuration, $schemaFileInfo['path']);
} else {
$data = $configuration;
}
if (empty($data)) {
$result->addNotice(new Notice('No configuration found, skipping schema "%s".', 1364985445, [substr($schemaFileInfo['file'], strlen(FLOW_PATH_ROOT))]));
} else {
$parsedSchema = Yaml::parse($schemaFileInfo['file']);
$validationResultForSingleSchema = $this->schemaValidator->validate($data, $parsedSchema);
if ($schemaFileInfo['path'] !== null) {
$result->forProperty($schemaFileInfo['path'])->merge($validationResultForSingleSchema);
} else {
$result->merge($validationResultForSingleSchema);
}
}
}
return $result;
}
/**
* @param string $driver
* @param string $user
* @param string $password
* @param string $host
* @return array
*/
protected function buildConnectionSettingsArray($driver, $user, $password, $host)
{
$settings = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.Flow');
$connectionSettings = $settings['persistence']['backendOptions'];
$connectionSettings['driver'] = $driver;
$connectionSettings['user'] = $user;
$connectionSettings['password'] = $password;
$connectionSettings['host'] = $host;
if ($connectionSettings['driver'] === 'pdo_pgsql') {
$connectionSettings['dbname'] = 'template1';
return $connectionSettings;
} else {
unset($connectionSettings['dbname']);
return $connectionSettings;
}
}
/**
* Generate a schema for the given configuration or YAML file.
*
* ./flow configuration:generateschema --type Settings --path Neos.Flow.persistence
*
* The schema will be output to standard output.
*
* @param string $type Configuration type to create a schema for
* @param string $path path to the subconfiguration separated by "." like "Neos.Flow"
* @param string $yaml YAML file to create a schema for
* @return void
*/
public function generateSchemaCommand($type = null, $path = null, $yaml = null)
{
$data = null;
if ($yaml !== null && is_file($yaml) && is_readable($yaml)) {
$data = Yaml::parse($yaml);
} elseif ($type !== null) {
$data = $this->configurationManager->getConfiguration($type);
if ($path !== null) {
$data = Arrays::getValueByPath($data, $path);
}
}
if (empty($data)) {
$this->outputLine('Data was not found or is empty');
$this->quit(1);
}
$this->outputLine(Yaml::dump($this->schemaGenerator->generate($data), 99));
}
/**
* Loads all node types into memory.
*
* @return void
*/
protected function loadNodeTypes()
{
$this->fullNodeTypeConfigurations = $this->fullConfigurationCache->get('fullNodeTypeConfigurations');
$fillFullConfigurationCache = !is_array($this->fullNodeTypeConfigurations);
$completeNodeTypeConfiguration = $this->configurationManager->getConfiguration('NodeTypes');
foreach (array_keys($completeNodeTypeConfiguration) as $nodeTypeName) {
if (!is_array($completeNodeTypeConfiguration[$nodeTypeName])) {
continue;
}
$nodeType = $this->loadNodeType($nodeTypeName, $completeNodeTypeConfiguration, isset($this->fullNodeTypeConfigurations[$nodeTypeName]) ? $this->fullNodeTypeConfigurations[$nodeTypeName] : null);
if ($fillFullConfigurationCache) {
$this->fullNodeTypeConfigurations[$nodeTypeName] = $nodeType->getFullConfiguration();
}
}
if ($fillFullConfigurationCache) {
$this->fullConfigurationCache->set('fullNodeTypeConfigurations', $this->fullNodeTypeConfigurations);
}
$this->fullNodeTypeConfigurations = null;
}
/**
* FIXME: Not yet completely refactored to new proxy mechanism
*
* @param array $argumentConfigurations
* @return string
*/
protected function buildMethodParametersCode(array $argumentConfigurations)
{
$preparedArguments = [];
foreach ($argumentConfigurations as $argument) {
if ($argument === null) {
$preparedArguments[] = 'NULL';
} else {
$argumentValue = $argument->getValue();
switch ($argument->getType()) {
case ConfigurationArgument::ARGUMENT_TYPES_OBJECT:
if ($argumentValue instanceof Configuration) {
$argumentValueObjectName = $argumentValue->getObjectName();
if ($this->objectConfigurations[$argumentValueObjectName]->getScope() === Configuration::SCOPE_PROTOTYPE) {
$preparedArguments[] = 'new \\' . $argumentValueObjectName . '(' . $this->buildMethodParametersCode($argumentValue->getArguments(), $this->objectConfigurations) . ')';
} else {
$preparedArguments[] = '\\Neos\\Flow\\Core\\Bootstrap::$staticObjectManager->get(\'' . $argumentValueObjectName . '\')';
}
} else {
if (strpos($argumentValue, '.') !== false) {
$settingPath = explode('.', $argumentValue);
$settings = Arrays::getValueByPath($this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS), array_shift($settingPath));
$argumentValue = Arrays::getValueByPath($settings, $settingPath);
}
$preparedArguments[] = '\\Neos\\Flow\\Core\\Bootstrap::$staticObjectManager->get(\'' . $argumentValue . '\')';
}
break;
case ConfigurationArgument::ARGUMENT_TYPES_STRAIGHTVALUE:
$preparedArguments[] = var_export($argumentValue, true);
break;
case ConfigurationArgument::ARGUMENT_TYPES_SETTING:
$preparedArguments[] = '\\Neos\\Flow\\Core\\Bootstrap::$staticObjectManager->getSettingsByPath(explode(\'.\', \'' . $argumentValue . '\'))';
break;
}
}
}
return implode(', ', $preparedArguments);
}
/**
* Checks if a routes configuration was set and otherwise loads the configuration from the configuration manager.
*
* @return void
*/
protected function initializeRoutesConfiguration()
{
if ($this->routesConfiguration === null) {
$this->routesConfiguration = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_ROUTES);
}
}
/**
* @return void
* @internal
*/
public function initializeObject()
{
$this->formSettings = $this->configurationManager->getConfiguration(\Neos\Flow\Configuration\ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.Form');
}
/**
* @test
*/
public function injectionOfOtherConfigurationTypes()
{
$classWithInjectedConfiguration = new Fixtures\ClassWithInjectedConfiguration();
$this->assertSame($this->configurationManager->getConfiguration('Views'), $classWithInjectedConfiguration->getInjectedViewsConfiguration());
}
/**
* Parses the global policy configuration and initializes roles and privileges accordingly
*
* @return void
* @throws SecurityException
*/
protected function initialize()
{
if ($this->initialized) {
return;
}
$this->policyConfiguration = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_POLICY);
$this->emitConfigurationLoaded($this->policyConfiguration);
$this->initializePrivilegeTargets();
$privilegeTargetsForEverybody = $this->privilegeTargets;
$this->roles = [];
$everybodyRole = new Role('Neos.Flow:Everybody');
$everybodyRole->setAbstract(true);
if (isset($this->policyConfiguration['roles'])) {
foreach ($this->policyConfiguration['roles'] as $roleIdentifier => $roleConfiguration) {
if ($roleIdentifier === 'Neos.Flow:Everybody') {
$role = $everybodyRole;
} else {
$role = new Role($roleIdentifier);
if (isset($roleConfiguration['abstract'])) {
$role->setAbstract((bool) $roleConfiguration['abstract']);
}
}
if (isset($roleConfiguration['privileges'])) {
foreach ($roleConfiguration['privileges'] as $privilegeConfiguration) {
$privilegeTargetIdentifier = $privilegeConfiguration['privilegeTarget'];
if (!isset($this->privilegeTargets[$privilegeTargetIdentifier])) {
throw new SecurityException(sprintf('privilege target "%s", referenced in role configuration "%s" is not defined!', $privilegeTargetIdentifier, $roleIdentifier), 1395869320);
}
$privilegeTarget = $this->privilegeTargets[$privilegeTargetIdentifier];
if (!isset($privilegeConfiguration['permission'])) {
throw new SecurityException(sprintf('No permission set for privilegeTarget "%s" in Role "%s"', $privilegeTargetIdentifier, $roleIdentifier), 1395869331);
}
$privilegeParameters = isset($privilegeConfiguration['parameters']) ? $privilegeConfiguration['parameters'] : [];
try {
$privilege = $privilegeTarget->createPrivilege($privilegeConfiguration['permission'], $privilegeParameters);
} catch (\Exception $exception) {
throw new SecurityException(sprintf('Error for privilegeTarget "%s" in Role "%s": %s', $privilegeTargetIdentifier, $roleIdentifier, $exception->getMessage()), 1401886654, $exception);
}
$role->addPrivilege($privilege);
if ($roleIdentifier === 'Neos.Flow:Everybody') {
unset($privilegeTargetsForEverybody[$privilegeTargetIdentifier]);
}
}
}
$this->roles[$roleIdentifier] = $role;
}
}
// create ABSTAIN privilege for all uncovered privilegeTargets
/** @var PrivilegeTarget $privilegeTarget */
foreach ($privilegeTargetsForEverybody as $privilegeTarget) {
if ($privilegeTarget->hasParameters()) {
continue;
}
$everybodyRole->addPrivilege($privilegeTarget->createPrivilege(PrivilegeInterface::ABSTAIN));
}
$this->roles['Neos.Flow:Everybody'] = $everybodyRole;
// Set parent roles
/** @var Role $role */
foreach ($this->roles as $role) {
if (isset($this->policyConfiguration['roles'][$role->getIdentifier()]['parentRoles'])) {
foreach ($this->policyConfiguration['roles'][$role->getIdentifier()]['parentRoles'] as $parentRoleIdentifier) {
$role->addParentRole($this->roles[$parentRoleIdentifier]);
}
}
}
$this->emitRolesInitialized($this->roles);
$this->initialized = true;
}
/**
* Initializes the Configuration Manager, the Flow settings and the Environment service
*
* @param Bootstrap $bootstrap
* @return void
* @throws FlowException
*/
public static function initializeConfiguration(Bootstrap $bootstrap)
{
$context = $bootstrap->getContext();
$environment = new Environment($context);
$environment->setTemporaryDirectoryBase(FLOW_PATH_TEMPORARY_BASE);
$bootstrap->setEarlyInstance(Environment::class, $environment);
$packageManager = $bootstrap->getEarlyInstance(PackageManagerInterface::class);
$configurationManager = new ConfigurationManager($context);
$configurationManager->setTemporaryDirectoryPath($environment->getPathToTemporaryDirectory());
$configurationManager->injectConfigurationSource(new YamlSource());
$configurationManager->setPackages($packageManager->getActivePackages());
$configurationManager->loadConfigurationCache();
$settings = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.Flow');
$lockManager = new LockManager($settings['utility']['lockStrategyClassName'], ['lockDirectory' => Files::concatenatePaths([$environment->getPathToTemporaryDirectory(), 'Lock'])]);
Lock::setLockManager($lockManager);
$packageManager->injectSettings($settings);
$bootstrap->getSignalSlotDispatcher()->dispatch(ConfigurationManager::class, 'configurationManagerReady', [$configurationManager]);
$bootstrap->setEarlyInstance(ConfigurationManager::class, $configurationManager);
}
/**
* Initializes the Configuration Manager, the Flow settings and the Environment service
*
* @param Bootstrap $bootstrap
* @return void
* @throws FlowException
*/
public static function initializeConfiguration(Bootstrap $bootstrap)
{
$context = $bootstrap->getContext();
$packageManager = $bootstrap->getEarlyInstance(PackageManagerInterface::class);
$configurationManager = new ConfigurationManager($context);
$configurationManager->injectConfigurationSource(new YamlSource());
$configurationManager->loadConfigurationCache();
$configurationManager->setPackages($packageManager->getActivePackages());
$settings = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.Flow');
$environment = new Environment($context);
if (isset($settings['utility']['environment']['temporaryDirectoryBase'])) {
$defaultTemporaryDirectoryBase = FLOW_PATH_DATA . '/Temporary';
if (FLOW_PATH_TEMPORARY_BASE !== $defaultTemporaryDirectoryBase) {
throw new FlowException(sprintf('It seems like the PHP default temporary base path has been changed from "%s" to "%s" via the FLOW_PATH_TEMPORARY_BASE environment variable. If that variable is present, the Neos.Flow.utility.environment.temporaryDirectoryBase setting must not be specified!', $defaultTemporaryDirectoryBase, FLOW_PATH_TEMPORARY_BASE), 1447707261);
}
$environment->setTemporaryDirectoryBase($settings['utility']['environment']['temporaryDirectoryBase']);
} else {
$environment->setTemporaryDirectoryBase(FLOW_PATH_TEMPORARY_BASE);
}
$configurationManager->setTemporaryDirectoryPath($environment->getPathToTemporaryDirectory());
$lockManager = new LockManager($settings['utility']['lockStrategyClassName'], ['lockDirectory' => Files::concatenatePaths([$environment->getPathToTemporaryDirectory(), 'Lock'])]);
Lock::setLockManager($lockManager);
$packageManager->injectSettings($settings);
$bootstrap->getSignalSlotDispatcher()->dispatch(ConfigurationManager::class, 'configurationManagerReady', [$configurationManager]);
$bootstrap->setEarlyInstance(ConfigurationManager::class, $configurationManager);
$bootstrap->setEarlyInstance(Environment::class, $environment);
}
/**
* @param ConfigurationManager $configurationManager
* @return void
*/
public function injectConfigurationManager(ConfigurationManager $configurationManager)
{
$this->contentDimensionsConfiguration = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.ContentRepository.contentDimensions');
}
/**
* Return the specified settings
*
* Examples::
*
* Configuration.setting('Neos.Flow.core.context') == 'Production'
*
* Configuration.setting('Acme.Demo.speedMode') == 'light speed'
*
* @param string $settingPath
* @return mixed
*/
public function setting($settingPath)
{
return $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $settingPath);
}