A package is active, if it is available and has been activated in the package
manager settings.
|
public getActivePackages ( ) : array |
||
| return | array |
|
public function initializeObject($reason)
{
if ($reason === ObjectManagerInterface::INITIALIZATIONCAUSE_RECREATED) {
return;
}
/** @var Package $package */
foreach ($this->packageManager->getActivePackages() as $package) {
foreach ($package->getNamespaces() as $namespace) {
$this->addNamespace(strtolower($package->getPackageKey()), $namespace . '\\ViewHelpers');
}
}
}
/**
* Index action
*
* @return void
*/
public function indexAction()
{
$this->view->assign('flowPathRoot', realpath(FLOW_PATH_ROOT));
$this->view->assign('flowPathWeb', realpath(FLOW_PATH_WEB));
$this->view->assign('isMyPackageActive', $this->packageManager->isPackageActive('MyCompany.MyPackage'));
$baseUri = $this->request->getHttpRequest()->getBaseUri();
$this->view->assign('baseUri', $baseUri);
$this->view->assign('isWindows', DIRECTORY_SEPARATOR !== '/');
$flowPackage = $this->packageManager->getPackage('Neos.Flow');
$version = $flowPackage->getInstalledVersion();
$this->view->assign('version', $version);
$activePackages = $this->packageManager->getActivePackages();
$this->view->assign('activePackages', $activePackages);
$this->view->assign('notDevelopmentContext', !$this->objectManager->getContext()->isDevelopment());
}
/**
* Flush all caches
*
* The flush command flushes all caches (including code caches) which have been
* registered with Flow's Cache Manager. It also removes any session data.
*
* If fatal errors caused by a package prevent the compile time bootstrap
* from running, the removal of any temporary data can be forced by specifying
* the option <b>--force</b>.
*
* This command does not remove the precompiled data provided by frozen
* packages unless the <b>--force</b> option is used.
*
* @param boolean $force Force flushing of any temporary data
* @return void
* @see neos.flow:cache:warmup
* @see neos.flow:package:freeze
* @see neos.flow:package:refreeze
*/
public function flushCommand($force = false)
{
// Internal note: the $force option is evaluated early in the Flow
// bootstrap in order to reliably flush the temporary data before any
// other code can cause fatal errors.
$this->cacheManager->flushCaches();
$this->outputLine('Flushed all caches for "' . $this->bootstrap->getContext() . '" context.');
if ($this->lockManager->isSiteLocked()) {
$this->lockManager->unlockSite();
}
$frozenPackages = [];
foreach (array_keys($this->packageManager->getActivePackages()) as $packageKey) {
if ($this->packageManager->isPackageFrozen($packageKey)) {
$frozenPackages[] = $packageKey;
}
}
if ($frozenPackages !== []) {
$this->outputFormatted(PHP_EOL . 'Please note that the following package' . (count($frozenPackages) === 1 ? ' is' : 's are') . ' currently frozen: ' . PHP_EOL);
$this->outputFormatted(implode(PHP_EOL, $frozenPackages) . PHP_EOL, [], 2);
$message = 'As code and configuration changes in these packages are not detected, the application may respond ';
$message .= 'unexpectedly if modifications were done anyway or the remaining code relies on these changes.' . PHP_EOL . PHP_EOL;
$message .= 'You may call <b>package:refreeze all</b> in order to refresh frozen packages or use the <b>--force</b> ';
$message .= 'option of this <b>cache:flush</b> command to flush caches if Flow becomes unresponsive.' . PHP_EOL;
$this->outputFormatted($message, [$frozenPackages]);
}
$this->sendAndExit(0);
}
/**
* Return the configuration needed for Migrations.
*
* @return Configuration
*/
protected function getMigrationConfiguration()
{
$this->output = [];
$that = $this;
$outputWriter = new OutputWriter(function ($message) use($that) {
$that->output[] = $message;
});
/** @var \Doctrine\DBAL\Connection $connection */
$connection = $this->entityManager->getConnection();
$schemaManager = $connection->getSchemaManager();
if ($schemaManager->tablesExist(array('flow3_doctrine_migrationstatus')) === true) {
$schemaManager->renameTable('flow3_doctrine_migrationstatus', self::DOCTRINE_MIGRATIONSTABLENAME);
}
$configuration = new Configuration($connection, $outputWriter);
$configuration->setMigrationsNamespace(\Neos\Flow\Persistence\Doctrine\Migrations::class);
$configuration->setMigrationsDirectory(Files::concatenatePaths([FLOW_PATH_DATA, 'DoctrineMigrations']));
$configuration->setMigrationsTableName(self::DOCTRINE_MIGRATIONSTABLENAME);
$configuration->createMigrationTable();
$databasePlatformName = $this->getDatabasePlatformName();
/** @var PackageInterface $package */
foreach ($this->packageManager->getActivePackages() as $package) {
$path = Files::concatenatePaths([$package->getPackagePath(), 'Migrations', $databasePlatformName]);
if (is_dir($path)) {
$configuration->registerMigrationsFromDirectory($path);
}
}
return $configuration;
}
/**
* Returns the absolute paths of public resources directories of all active packages.
* This method is used directly by the FileSystemSymlinkTarget.
*
* @return array<string>
*/
public function getPublicResourcePaths()
{
$paths = [];
$packages = $this->packageManager->getActivePackages();
foreach ($packages as $packageKey => $package) {
/** @var PackageInterface $package */
$publicResourcesPath = Files::concatenatePaths([$package->getResourcesPath(), 'Public']);
if (is_dir($publicResourcesPath)) {
$paths[$packageKey] = $publicResourcesPath;
}
}
return $paths;
}
/**
* 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;
}
/**
* Finds all Locale objects representing locales available in the
* Flow installation. This is done by scanning all Private and Public
* resource files of all active packages, in order to find localized files.
*
* Localized files have a locale identifier added before their extension
* (or at the end of filename, if no extension exists). For example, a
* localized file for foobar.png, can be foobar.en.png, fobar.en_GB.png, etc.
*
* Just one localized resource file causes the corresponding locale to be
* regarded as available (installed, supported).
*
* Note: result of this method invocation is cached
*
* @return void
*/
protected function generateAvailableLocalesCollectionByScanningFilesystem()
{
$whitelistPaths = array_keys(array_filter((array) $this->settings['scan']['includePaths']));
if ($whitelistPaths === []) {
return;
}
$blacklistPattern = $this->getScanBlacklistPattern();
/** @var PackageInterface $activePackage */
foreach ($this->packageManager->getActivePackages() as $activePackage) {
$packageResourcesPath = Files::getNormalizedPath($activePackage->getResourcesPath());
if (!is_dir($packageResourcesPath)) {
continue;
}
$directories = [];
foreach ($whitelistPaths as $path) {
$scanPath = Files::concatenatePaths(array($packageResourcesPath, $path));
if (is_dir($scanPath)) {
array_push($directories, Files::getNormalizedPath($scanPath));
}
}
while ($directories !== []) {
$currentDirectory = array_pop($directories);
$relativeDirectory = '/' . str_replace($packageResourcesPath, '', $currentDirectory);
if ($blacklistPattern !== '' && preg_match($blacklistPattern, $relativeDirectory) === 1) {
continue;
}
if ($handle = opendir($currentDirectory)) {
while (false !== ($filename = readdir($handle))) {
if ($filename[0] === '.') {
continue;
}
$pathAndFilename = Files::concatenatePaths([$currentDirectory, $filename]);
if (is_dir($pathAndFilename)) {
array_push($directories, Files::getNormalizedPath($pathAndFilename));
} else {
$localeIdentifier = Utility::extractLocaleTagFromFilename($filename);
if ($localeIdentifier !== false) {
$this->localeCollection->addLocale(new Locale($localeIdentifier));
}
}
}
closedir($handle);
}
}
}
}
/**
* Freeze a package
*
* This function marks a package as <b>frozen</b> in order to improve performance
* in a development context. While a package is frozen, any modification of files
* within that package won't be tracked and can lead to unexpected behavior.
*
* File monitoring won't consider the given package. Further more, reflection
* data for classes contained in the package is cached persistently and loaded
* directly on the first request after caches have been flushed. The precompiled
* reflection data is stored in the <b>Configuration</b> directory of the
* respective package.
*
* By specifying <b>all</b> as a package key, all currently frozen packages are
* frozen (the default).
*
* @param string $packageKey Key of the package to freeze
* @return void
* @see neos.flow:package:unfreeze
* @see neos.flow:package:refreeze
*/
public function freezeCommand($packageKey = 'all')
{
if (!$this->bootstrap->getContext()->isDevelopment()) {
$this->outputLine('Package freezing is only supported in Development context.');
$this->quit(3);
}
$packagesToFreeze = [];
if ($packageKey === 'all') {
foreach (array_keys($this->packageManager->getActivePackages()) as $packageKey) {
if (!$this->packageManager->isPackageFrozen($packageKey)) {
$packagesToFreeze[] = $packageKey;
}
}
if ($packagesToFreeze === []) {
$this->outputLine('Nothing to do, all active packages were already frozen.');
$this->quit(0);
}
} elseif ($packageKey === 'blackberry') {
$this->outputLine('http://bit.ly/freeze-blackberry');
$this->quit(42);
} else {
if (!$this->packageManager->isPackageActive($packageKey)) {
if ($this->packageManager->isPackageAvailable($packageKey)) {
$this->outputLine('Package "%s" is not active and thus cannot be frozen.', [$packageKey]);
$this->quit(1);
} else {
$this->outputLine('Package "%s" is not available.', [$packageKey]);
$this->quit(2);
}
}
if ($this->packageManager->isPackageFrozen($packageKey)) {
$this->outputLine('Package "%s" was already frozen.', [$packageKey]);
$this->quit(0);
}
$packagesToFreeze = [$packageKey];
}
foreach ($packagesToFreeze as $packageKey) {
$this->packageManager->freezePackage($packageKey);
$this->outputLine('Froze package "%s".', [$packageKey]);
}
}
/**
* Prepares an array with TypoScript paths to auto include before the Site TypoScript.
*
* @return array
*/
protected function prepareAutoIncludeTypoScript()
{
$autoIncludeTypoScript = array();
foreach (array_keys($this->packageManager->getActivePackages()) as $packageKey) {
if (isset($this->autoIncludeConfiguration[$packageKey]) && $this->autoIncludeConfiguration[$packageKey] === true) {
$autoIncludeTypoScriptFile = sprintf($this->autoIncludeTypoScriptPattern, $packageKey);
if (is_file($autoIncludeTypoScriptFile)) {
$autoIncludeTypoScript[] = $autoIncludeTypoScriptFile;
} else {
// If there is no Root.fusion found in the default path pattern or the legacy path pattern
// use the default path pattern so an exception will show the correct path pattern and not a
// legacy path pattern
$legacyAutoIncludeTypoScriptFile = sprintf($this->legacyAutoIncludeTypoScriptPattern, $packageKey);
if (is_file($legacyAutoIncludeTypoScriptFile)) {
$autoIncludeTypoScript[] = $legacyAutoIncludeTypoScriptFile;
} else {
$autoIncludeTypoScript[] = $autoIncludeTypoScriptFile;
}
}
}
}
return $autoIncludeTypoScript;
}
/**
* Tries to load the reflection data from the compile time cache.
*
* The compile time cache is only supported for Development context and thus
* this function will return in any other context.
*
* If no reflection data was found, this method will at least load the precompiled
* reflection data of any possible frozen package. Even if precompiled reflection
* data could be loaded, FALSE will be returned in order to signal that other
* packages still need to be reflected.
*
* @return boolean TRUE if reflection data could be loaded, otherwise FALSE
*/
protected function loadClassReflectionCompiletimeCache()
{
$data = $this->reflectionDataCompiletimeCache->get('ReflectionData');
if ($data !== false) {
foreach ($data as $propertyName => $propertyValue) {
$this->{$propertyName} = $propertyValue;
}
return true;
}
if (!$this->context->isDevelopment()) {
return false;
}
$useIgBinary = extension_loaded('igbinary');
foreach ($this->packageManager->getActivePackages() as $packageKey => $package) {
if (!$this->packageManager->isPackageFrozen($packageKey)) {
continue;
}
$pathAndFilename = $this->getPrecompiledReflectionStoragePath() . $packageKey . '.dat';
if (!file_exists($pathAndFilename)) {
continue;
}
$data = $useIgBinary ? igbinary_unserialize(file_get_contents($pathAndFilename)) : unserialize(file_get_contents($pathAndFilename));
foreach ($data as $propertyName => $propertyValue) {
$this->{$propertyName} = Arrays::arrayMergeRecursiveOverrule($this->{$propertyName}, $propertyValue);
}
}
return false;
}
/**
* Prepares an array with TypoScript paths to auto include before the Site TypoScript.
*
* @return array
*/
protected function prepareAutoIncludeTypoScript()
{
$autoIncludeTypoScript = array();
foreach (array_keys($this->packageManager->getActivePackages()) as $packageKey) {
if (isset($this->autoIncludeConfiguration[$packageKey]) && $this->autoIncludeConfiguration[$packageKey] === true) {
$autoIncludeTypoScriptFile = sprintf($this->autoIncludeTypoScriptPattern, $packageKey);
if (is_file($autoIncludeTypoScriptFile)) {
$autoIncludeTypoScript[] = $autoIncludeTypoScriptFile;
} else {
$autoIncludeTypoScript[] = sprintf($this->legacyAutoIncludeTypoScriptPattern, $packageKey);
}
}
}
return $autoIncludeTypoScript;
}
