Returns an instance which was registered earlier through setEarlyInstance()
| public getEarlyInstance ( string $objectName ) : object | ||
| $objectName | string | Object name of the registered instance |
| return | object | |
/**
* Adds an HTTP header to the Response which indicates that the application is powered by Flow.
*
* @param Response $response
* @return void
*/
protected function addPoweredByHeader(Response $response)
{
if ($this->settings['http']['applicationToken'] === 'Off') {
return;
}
$applicationIsFlow = $this->settings['core']['applicationPackageKey'] === 'Neos.Flow';
if ($this->settings['http']['applicationToken'] === 'ApplicationName') {
if ($applicationIsFlow) {
$response->getHeaders()->set('X-Flow-Powered', 'Flow');
} else {
$response->getHeaders()->set('X-Flow-Powered', 'Flow ' . $this->settings['core']['applicationName']);
}
return;
}
/** @var Package $applicationPackage */
/** @var Package $flowPackage */
$flowPackage = $this->bootstrap->getEarlyInstance(PackageManagerInterface::class)->getPackage('Neos.Flow');
$applicationPackage = $this->bootstrap->getEarlyInstance(PackageManagerInterface::class)->getPackage($this->settings['core']['applicationPackageKey']);
if ($this->settings['http']['applicationToken'] === 'MajorVersion') {
$flowVersion = $this->renderMajorVersion($flowPackage->getInstalledVersion());
$applicationVersion = $this->renderMajorVersion($applicationPackage->getInstalledVersion());
} else {
$flowVersion = $this->renderMinorVersion($flowPackage->getInstalledVersion());
$applicationVersion = $this->renderMinorVersion($applicationPackage->getInstalledVersion());
}
if ($applicationIsFlow) {
$response->getHeaders()->set('X-Flow-Powered', 'Flow/' . ($flowVersion ?: 'dev'));
} else {
$response->getHeaders()->set('X-Flow-Powered', 'Flow/' . ($flowVersion ?: 'dev') . ' ' . $this->settings['core']['applicationName'] . '/' . ($applicationVersion ?: 'dev'));
}
}
/**
* Display a message. As we cannot rely on any Flow requirements being fulfilled here,
* we have to statically include the CSS styles at this point, and have to in-line the TYPO3 logo.
*
* @param array <\Neos\Error\Messages\Message> $messages Array of messages (at least one message must be passed)
* @param string $extraHeaderHtml extra HTML code to include at the end of the head tag
* @return void This method never returns.
*/
public function showMessages(array $messages, $extraHeaderHtml = '')
{
if ($messages === []) {
throw new \InvalidArgumentException('No messages given for rendering', 1416914970);
}
/** @var \Neos\Flow\Package\PackageManagerInterface $packageManager */
$packageManager = $this->bootstrap->getEarlyInstance(\Neos\Flow\Package\PackageManagerInterface::class);
$css = '';
if ($packageManager->isPackageAvailable('Neos.Twitter.Bootstrap')) {
$css .= file_get_contents($packageManager->getPackage('Neos.Twitter.Bootstrap')->getResourcesPath() . 'Public/3/css/bootstrap.min.css');
$css = str_replace('url(../', 'url(/_Resources/Static/Packages/Neos.Twitter.Bootstrap/3.0/', $css);
}
if ($packageManager->isPackageAvailable('Neos.Setup')) {
$css .= file_get_contents($packageManager->getPackage('Neos.Setup')->getResourcesPath() . 'Public/Styles/Setup.css');
$css = str_replace('url(\'../', 'url(\'/_Resources/Static/Packages/Neos.Setup/', $css);
}
echo '<html>';
echo '<head>';
echo '<title>Setup message</title>';
echo '<style type="text/css">';
echo $css;
echo '</style>';
echo $extraHeaderHtml;
echo '</head>';
echo '<body>';
$renderedMessages = $this->renderMessages($messages);
$lastMessage = end($messages);
echo sprintf('
<div class="logo"></div>
<div class="well">
<div class="container">
<ul class="breadcrumb">
<li><a class="active">Setup</a></li>
</ul>
<h3>%s</h3>
<div class="t3-module-container indented">
%s
</div>
</div>
</div>
', $lastMessage->getTitle(), $renderedMessages);
echo '</body></html>';
exit(0);
}
/**
* Emits a signal when package states have been changed (e.g. when a package was created or activated)
*
* The advice is not proxyable, so the signal is dispatched manually here.
*
* @return void
* @Flow\Signal
*/
protected function emitPackageStatesUpdated()
{
if ($this->bootstrap === null) {
return;
}
if ($this->dispatcher === null) {
$this->dispatcher = $this->bootstrap->getEarlyInstance(Dispatcher::class);
}
$this->dispatcher->dispatch(PackageManager::class, 'packageStatesUpdated');
}
/**
* @param Bootstrap $bootstrap The current bootstrap
* @return void
*/
public function boot(Bootstrap $bootstrap)
{
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$flushConfigurationCache = function () use($bootstrap) {
$cacheManager = $bootstrap->getEarlyInstance(CacheManager::class);
$cacheManager->getCache('TYPO3_Neos_Configuration_Version')->flush();
};
$flushXliffServiceCache = function () use($bootstrap) {
$cacheManager = $bootstrap->getEarlyInstance(CacheManager::class);
$cacheManager->getCache('TYPO3_Neos_XliffToJsonTranslations')->flush();
};
$dispatcher->connect(FileMonitor::class, 'filesHaveChanged', function ($fileMonitorIdentifier, array $changedFiles) use($flushConfigurationCache, $flushXliffServiceCache) {
switch ($fileMonitorIdentifier) {
case 'TYPO3CR_NodeTypesConfiguration':
case 'Flow_ConfigurationFiles':
$flushConfigurationCache();
break;
case 'Flow_TranslationFiles':
$flushConfigurationCache();
$flushXliffServiceCache();
}
});
$dispatcher->connect(Site::class, 'siteChanged', $flushConfigurationCache);
$dispatcher->connect(Site::class, 'siteChanged', RouterCachingService::class, 'flushCaches');
$dispatcher->connect(Node::class, 'nodeUpdated', ContentCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(Node::class, 'nodeAdded', ContentCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(Node::class, 'nodeRemoved', ContentCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(Node::class, 'beforeNodeMove', ContentCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(AssetService::class, 'assetResourceReplaced', ContentCacheFlusher::class, 'registerAssetResourceChange');
$dispatcher->connect(Node::class, 'nodeAdded', NodeUriPathSegmentGenerator::class, '::setUniqueUriPathSegment');
$dispatcher->connect(Node::class, 'nodePropertyChanged', Service\ImageVariantGarbageCollector::class, 'removeUnusedImageVariant');
$dispatcher->connect(Node::class, 'nodePropertyChanged', function (NodeInterface $node, $propertyName) use($bootstrap) {
if ($propertyName === 'uriPathSegment') {
NodeUriPathSegmentGenerator::setUniqueUriPathSegment($node);
$bootstrap->getObjectManager()->get(RouteCacheFlusher::class)->registerNodeChange($node);
}
});
$dispatcher->connect(Node::class, 'nodePathChanged', function (NodeInterface $node, $oldPath, $newPath, $recursion) {
if (!$recursion) {
NodeUriPathSegmentGenerator::setUniqueUriPathSegment($node);
}
});
$dispatcher->connect(PublishingService::class, 'nodePublished', ContentCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(PublishingService::class, 'nodeDiscarded', ContentCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(Node::class, 'nodePathChanged', RouteCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(Node::class, 'nodeRemoved', RouteCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(PublishingService::class, 'nodeDiscarded', RouteCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(PublishingService::class, 'nodePublished', RouteCacheFlusher::class, 'registerNodeChange');
$dispatcher->connect(PublishingService::class, 'nodePublished', function ($node, $targetWorkspace) use($bootstrap) {
$cacheManager = $bootstrap->getObjectManager()->get(CacheManager::class);
if ($cacheManager->hasCache('Flow_Persistence_Doctrine')) {
$cacheManager->getCache('Flow_Persistence_Doctrine')->flush();
}
});
$dispatcher->connect(PersistenceManager::class, 'allObjectsPersisted', RouteCacheFlusher::class, 'commit');
$dispatcher->connect(SiteService::class, 'sitePruned', ContentCache::class, 'flush');
$dispatcher->connect(SiteService::class, 'sitePruned', RouterCachingService::class, 'flushCaches');
$dispatcher->connect(SiteImportService::class, 'siteImported', ContentCache::class, 'flush');
$dispatcher->connect(SiteImportService::class, 'siteImported', RouterCachingService::class, 'flushCaches');
// Eventlog
$dispatcher->connect(Node::class, 'beforeNodeCreate', ContentRepositoryIntegrationService::class, 'beforeNodeCreate');
$dispatcher->connect(Node::class, 'afterNodeCreate', ContentRepositoryIntegrationService::class, 'afterNodeCreate');
$dispatcher->connect(Node::class, 'nodeUpdated', ContentRepositoryIntegrationService::class, 'nodeUpdated');
$dispatcher->connect(Node::class, 'nodeRemoved', ContentRepositoryIntegrationService::class, 'nodeRemoved');
$dispatcher->connect(Node::class, 'beforeNodePropertyChange', ContentRepositoryIntegrationService::class, 'beforeNodePropertyChange');
$dispatcher->connect(Node::class, 'nodePropertyChanged', ContentRepositoryIntegrationService::class, 'nodePropertyChanged');
$dispatcher->connect(Node::class, 'beforeNodeCopy', ContentRepositoryIntegrationService::class, 'beforeNodeCopy');
$dispatcher->connect(Node::class, 'afterNodeCopy', ContentRepositoryIntegrationService::class, 'afterNodeCopy');
$dispatcher->connect(Node::class, 'beforeNodeMove', ContentRepositoryIntegrationService::class, 'beforeNodeMove');
$dispatcher->connect(Node::class, 'afterNodeMove', ContentRepositoryIntegrationService::class, 'afterNodeMove');
$dispatcher->connect(Context::class, 'beforeAdoptNode', ContentRepositoryIntegrationService::class, 'beforeAdoptNode');
$dispatcher->connect(Context::class, 'afterAdoptNode', ContentRepositoryIntegrationService::class, 'afterAdoptNode');
$dispatcher->connect(Workspace::class, 'beforeNodePublishing', ContentRepositoryIntegrationService::class, 'beforeNodePublishing');
$dispatcher->connect(Workspace::class, 'afterNodePublishing', ContentRepositoryIntegrationService::class, 'afterNodePublishing');
$dispatcher->connect(PersistenceManager::class, 'allObjectsPersisted', ContentRepositoryIntegrationService::class, 'updateEventsAfterPublish');
$dispatcher->connect(NodeDataRepository::class, 'repositoryObjectsPersisted', ContentRepositoryIntegrationService::class, 'updateEventsAfterPublish');
}
<?php
/*
* This file configures dynamic return type support for factory methods in PhpStorm
*/
namespace PHPSTORM_META;
$STATIC_METHOD_TYPES = [\Neos\Flow\ObjectManagement\ObjectManagerInterface::get('') => ['' == '@'], \Neos\Flow\Core\Bootstrap::getEarlyInstance('') => ['' == '@']];
/**
* Update Doctrine 2 proxy classes
*
* This is not simply bound to the finishedCompilationRun signal because it
* needs the advised proxy classes to run. When that signal is fired, they
* have been written, but not loaded.
*
* @param Bootstrap $bootstrap
* @return void
*/
protected static function compileDoctrineProxies(Bootstrap $bootstrap)
{
$cacheManager = $bootstrap->getEarlyInstance(CacheManager::class);
$objectConfigurationCache = $cacheManager->getCache('Flow_Object_Configuration');
$coreCache = $cacheManager->getCache('Flow_Core');
$systemLogger = $bootstrap->getEarlyInstance(SystemLoggerInterface::class);
$configurationManager = $bootstrap->getEarlyInstance(ConfigurationManager::class);
$settings = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.Flow');
if ($objectConfigurationCache->has('doctrineProxyCodeUpToDate') === false && $coreCache->has('doctrineSetupRunning') === false) {
$coreCache->set('doctrineSetupRunning', 'White Russian', [], 60);
$systemLogger->log('Compiling Doctrine proxies', LOG_DEBUG);
self::executeCommand('neos.flow:doctrine:compileproxies', $settings);
$coreCache->remove('doctrineSetupRunning');
$objectConfigurationCache->set('doctrineProxyCodeUpToDate', true);
}
}
/**
* Helper method to create a FileMonitor instance during boot sequence as injections have to be done manually.
*
* @param string $identifier
* @param Bootstrap $bootstrap
* @return FileMonitor
*/
public static function createFileMonitorAtBoot($identifier, Bootstrap $bootstrap)
{
$fileMonitorCache = $bootstrap->getEarlyInstance(CacheManager::class)->getCache('Flow_Monitor');
// The change detector needs to be instantiated and registered manually because
// it has a complex dependency (cache) but still needs to be a singleton.
$fileChangeDetector = new ChangeDetectionStrategy\ModificationTimeStrategy();
$fileChangeDetector->injectCache($fileMonitorCache);
$bootstrap->getObjectManager()->registerShutdownObject($fileChangeDetector, 'shutdownObject');
$fileMonitor = new FileMonitor($identifier);
$fileMonitor->injectCache($fileMonitorCache);
$fileMonitor->injectChangeDetectionStrategy($fileChangeDetector);
$fileMonitor->injectSignalDispatcher($bootstrap->getEarlyInstance(Dispatcher::class));
$fileMonitor->injectSystemLogger($bootstrap->getEarlyInstance(SystemLoggerInterface::class));
return $fileMonitor;
}
