/** * Sets up this test case * */ protected function setUp() { ComposerUtility::flushCaches(); vfsStream::setup('Test'); $this->mockBootstrap = $this->getMockBuilder(Bootstrap::class)->disableOriginalConstructor()->getMock(); $this->mockBootstrap->expects($this->any())->method('getSignalSlotDispatcher')->will($this->returnValue($this->createMock(Dispatcher::class))); $this->mockApplicationContext = $this->getMockBuilder(ApplicationContext::class)->disableOriginalConstructor()->getMock(); $this->mockBootstrap->expects($this->any())->method('getContext')->will($this->returnValue($this->mockApplicationContext)); $mockObjectManager = $this->createMock(ObjectManagerInterface::class); $this->mockBootstrap->expects($this->any())->method('getObjectManager')->will($this->returnValue($mockObjectManager)); $mockReflectionService = $this->createMock(ReflectionService::class); $mockReflectionService->expects($this->any())->method('getClassNameByObject')->will($this->returnCallback(function ($object) { if ($object instanceof \Doctrine\ORM\Proxy\Proxy) { return get_parent_class($object); } return get_class($object); })); $mockObjectManager->expects($this->any())->method('get')->with(ReflectionService::class)->will($this->returnValue($mockReflectionService)); mkdir('vfs://Test/Packages/Application', 0700, true); mkdir('vfs://Test/Configuration'); $this->packageManager = new PackageManager('vfs://Test/Configuration/PackageStates.php'); $composerNameToPackageKeyMap = ['neos/flow' => 'Neos.Flow']; $this->inject($this->packageManager, 'composerNameToPackageKeyMap', $composerNameToPackageKeyMap); $this->inject($this->packageManager, 'packagesBasePath', 'vfs://Test/Packages/'); $this->mockDispatcher = $this->getMockBuilder(Dispatcher::class)->disableOriginalConstructor()->getMock(); $this->inject($this->packageManager, 'dispatcher', $this->mockDispatcher); $this->packageManager->initialize($this->mockBootstrap); }
/** * Invokes custom PHP code directly after the package manager has been initialized. * * @param Bootstrap $bootstrap The current bootstrap * @return void */ public function boot(Bootstrap $bootstrap) { $dispatcher = $bootstrap->getSignalSlotDispatcher(); $context = $bootstrap->getContext(); if (!$context->isProduction()) { $dispatcher->connect(Sequence::class, 'afterInvokeStep', function ($step) use($bootstrap, $dispatcher) { if ($step->getIdentifier() === 'typo3.flow:systemfilemonitor') { $typoScriptFileMonitor = FileMonitor::createFileMonitorAtBoot('TypoScript_Files', $bootstrap); $packageManager = $bootstrap->getEarlyInstance(PackageManagerInterface::class); foreach ($packageManager->getActivePackages() as $packageKey => $package) { if ($packageManager->isPackageFrozen($packageKey)) { continue; } $typoScriptPaths = array($package->getResourcesPath() . 'Private/TypoScript', $package->getResourcesPath() . 'Private/TypoScripts'); foreach ($typoScriptPaths as $typoScriptPath) { if (is_dir($typoScriptPath)) { $typoScriptFileMonitor->monitorDirectory($typoScriptPath); } } } $typoScriptFileMonitor->detectChanges(); $typoScriptFileMonitor->shutdownObject(); } if ($step->getIdentifier() === 'typo3.flow:cachemanagement') { $cacheManager = $bootstrap->getEarlyInstance(CacheManager::class); $listener = new FileMonitorListener($cacheManager); $dispatcher->connect(FileMonitor::class, 'filesHaveChanged', $listener, 'flushContentCacheOnFileChanges'); } }); } }
/** * @test * @dataProvider commandIdentifiersAndCompiletimeControllerInfo */ public function isCompileTimeCommandControllerChecksIfTheGivenCommandIdentifierRefersToACompileTimeController($compiletimeCommandControllerIdentifiers, $givenCommandIdentifier, $expectedResult) { $bootstrap = new Bootstrap('Testing'); foreach ($compiletimeCommandControllerIdentifiers as $compiletimeCommandControllerIdentifier) { $bootstrap->registerCompiletimeCommand($compiletimeCommandControllerIdentifier); } $this->assertSame($expectedResult, $bootstrap->isCompiletimeCommand($givenCommandIdentifier)); }
/** * @return Domain */ public function findOneByActiveRequest() { $matchingDomain = null; $activeRequestHandler = $this->bootstrap->getActiveRequestHandler(); if ($activeRequestHandler instanceof HttpRequestHandlerInterface) { $matchingDomain = $this->findOneByHost($activeRequestHandler->getHttpRequest()->getUri()->getHost(), true); } return $matchingDomain; }
public function setUp() { $this->fileSystemTarget = new FileSystemTarget('test'); $this->mockBootstrap = $this->getMockBuilder(Bootstrap::class)->disableOriginalConstructor()->getMock(); $this->mockRequestHandler = $this->createMock(HttpRequestHandlerInterface::class); $this->mockHttpRequest = $this->getMockBuilder(Request::class)->disableOriginalConstructor()->getMock(); $this->mockHttpRequest->expects($this->any())->method('getBaseUri')->will($this->returnValue(new Uri('http://detected/base/uri/'))); $this->mockRequestHandler->expects($this->any())->method('getHttpRequest')->will($this->returnValue($this->mockHttpRequest)); $this->mockBootstrap->expects($this->any())->method('getActiveRequestHandler')->will($this->returnValue($this->mockRequestHandler)); $this->inject($this->fileSystemTarget, 'bootstrap', $this->mockBootstrap); }
/** * @return void */ public function setUp() { parent::setup(); vfsStream::setup('Foo'); $this->httpRequest = Http\Request::create(new Http\Uri('http://localhost')); $this->httpResponse = new Http\Response(); $mockRequestHandler = $this->createMock(Http\RequestHandler::class); $mockRequestHandler->expects($this->any())->method('getHttpRequest')->will($this->returnValue($this->httpRequest)); $mockRequestHandler->expects($this->any())->method('getHttpResponse')->will($this->returnValue($this->httpResponse)); $this->mockBootstrap = $this->createMock(Bootstrap::class); $this->mockBootstrap->expects($this->any())->method('getActiveRequestHandler')->will($this->returnValue($mockRequestHandler)); $this->mockSecurityContext = $this->createMock(Context::class); $this->mockObjectManager = $this->createMock(ObjectManagerInterface::class); $this->mockObjectManager->expects($this->any())->method('get')->with(Context::class)->will($this->returnValue($this->mockSecurityContext)); }
/** * Sends the given HTTP request * * @param Http\Request $httpRequest * @return Http\Response * @throws Http\Exception * @api */ public function sendRequest(Http\Request $httpRequest) { $requestHandler = $this->bootstrap->getActiveRequestHandler(); if (!$requestHandler instanceof FunctionalTestRequestHandler) { throw new Http\Exception('The browser\'s internal request engine has only been designed for use within functional tests.', 1335523749); } $this->securityContext->clearContext(); $this->validatorResolver->reset(); $response = new Http\Response(); $componentContext = new ComponentContext($httpRequest, $response); $requestHandler->setComponentContext($componentContext); $objectManager = $this->bootstrap->getObjectManager(); $baseComponentChain = $objectManager->get(\Neos\Flow\Http\Component\ComponentChain::class); $componentContext = new ComponentContext($httpRequest, $response); try { $baseComponentChain->handle($componentContext); } catch (\Throwable $throwable) { $this->prepareErrorResponse($throwable, $componentContext->getHttpResponse()); } catch (\Exception $exception) { $this->prepareErrorResponse($exception, $componentContext->getHttpResponse()); } $session = $this->bootstrap->getObjectManager()->get(SessionInterface::class); if ($session->isStarted()) { $session->close(); } $this->persistenceManager->clearState(); return $componentContext->getHttpResponse(); }
/** * Returns an array that contains all available command identifiers and their shortest non-ambiguous alias * * @return array in the format array('full.command:identifier1' => 'alias1', 'full.command:identifier2' => 'alias2') */ protected function getShortCommandIdentifiers() { if ($this->shortCommandIdentifiers === null) { $commandsByCommandName = []; /** @var Command $availableCommand */ foreach ($this->getAvailableCommands() as $availableCommand) { list($packageKey, $controllerName, $commandName) = explode(':', $availableCommand->getCommandIdentifier()); if (!isset($commandsByCommandName[$commandName])) { $commandsByCommandName[$commandName] = []; } if (!isset($commandsByCommandName[$commandName][$controllerName])) { $commandsByCommandName[$commandName][$controllerName] = []; } $commandsByCommandName[$commandName][$controllerName][] = $packageKey; } foreach ($this->getAvailableCommands() as $availableCommand) { list($packageKey, $controllerName, $commandName) = explode(':', $availableCommand->getCommandIdentifier()); if (count($commandsByCommandName[$commandName][$controllerName]) > 1 || $this->bootstrap->isCompiletimeCommand($availableCommand->getCommandIdentifier())) { $packageKeyParts = array_reverse(explode('.', $packageKey)); for ($i = 1; $i <= count($packageKeyParts); $i++) { $shortCommandIdentifier = implode('.', array_slice($packageKeyParts, 0, $i)) . ':' . $controllerName . ':' . $commandName; try { $this->getCommandByIdentifier($shortCommandIdentifier); $this->shortCommandIdentifiers[$availableCommand->getCommandIdentifier()] = $shortCommandIdentifier; break; } catch (CommandException $exception) { } } } else { $this->shortCommandIdentifiers[$availableCommand->getCommandIdentifier()] = sprintf('%s:%s', $controllerName, $commandName); } } } return $this->shortCommandIdentifiers; }
/** * 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')); } }
/** * Starts the shutdown sequence * * @param string $runlevel one of the Bootstrap::RUNLEVEL_* constants * @return void */ protected function shutdown($runlevel) { $this->bootstrap->shutdown($runlevel); if ($runlevel === Bootstrap::RUNLEVEL_COMPILETIME) { $this->objectManager->get(LockManager::class)->unlockSite(); } exit($this->response->getExitCode()); }
/** * 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'); }
/** * Invokes custom PHP code directly after the package manager has been initialized. * * @param Bootstrap $bootstrap The current bootstrap * @return void */ public function boot(Bootstrap $bootstrap) { $dispatcher = $bootstrap->getSignalSlotDispatcher(); $context = $bootstrap->getContext(); if (!$context->isProduction()) { $dispatcher->connect(Sequence::class, 'afterInvokeStep', function ($step) use($bootstrap, $dispatcher) { if ($step->getIdentifier() === 'neos.flow:systemfilemonitor') { $templateFileMonitor = FileMonitor::createFileMonitorAtBoot('Fluid_TemplateFiles', $bootstrap); $packageManager = $bootstrap->getEarlyInstance(PackageManagerInterface::class); foreach ($packageManager->getActivePackages() as $packageKey => $package) { if ($packageManager->isPackageFrozen($packageKey)) { continue; } foreach (array('Templates', 'Partials', 'Layouts') as $path) { $templatesPath = $package->getResourcesPath() . 'Private/' . $path; if (is_dir($templatesPath)) { $templateFileMonitor->monitorDirectory($templatesPath); } } } $templateFileMonitor->detectChanges(); $templateFileMonitor->shutdownObject(); } }); } // Use a closure to invoke the TemplateCompiler, since the object is not registered during compiletime $flushTemplates = function ($identifier, $changedFiles) use($bootstrap) { if ($identifier !== 'Fluid_TemplateFiles') { return; } if ($changedFiles === []) { return; } $templateCache = $bootstrap->getObjectManager()->get(CacheManager::class)->getCache('Fluid_TemplateCache'); $templateCache->flush(); }; $dispatcher->connect(FileMonitor::class, 'filesHaveChanged', $flushTemplates); }
/** * Returns autocomplete suggestions on hitting the TAB key. * * @param string $partialCommand The current (partial) command where the TAB key was hit * @param integer $index The cursor index at the current (partial) command * @return array */ protected function autocomplete($partialCommand, $index) { // @TODO Add more functionality by parsing the current buffer with readline_info() // @TODO Filter file system elements (if possible at all) $suggestions = []; $availableCommands = $this->bootstrap->getObjectManager()->get(CommandManager::class)->getAvailableCommands(); /** @var $command Command */ foreach ($availableCommands as $command) { if ($command->isInternal() === false) { $suggestions[] = $command->getCommandIdentifier(); } } return $suggestions; }
/** * Invokes custom PHP code directly after the package manager has been initialized. * * @param Bootstrap $bootstrap The current bootstrap * @return void */ public function boot(Bootstrap $bootstrap) { $dispatcher = $bootstrap->getSignalSlotDispatcher(); $dispatcher->connect(PersistenceManager::class, 'allObjectsPersisted', NodeDataRepository::class, 'flushNodeRegistry'); $dispatcher->connect(NodeDataRepository::class, 'repositoryObjectsPersisted', NodeDataRepository::class, 'flushNodeRegistry'); $dispatcher->connect(Node::class, 'nodePathChanged', function () use($bootstrap) { $contextFactory = $bootstrap->getObjectManager()->get(ContextFactoryInterface::class); /** @var Context $contextInstance */ foreach ($contextFactory->getInstances() as $contextInstance) { $contextInstance->getFirstLevelNodeCache()->flush(); } }); $dispatcher->connect(ConfigurationManager::class, 'configurationManagerReady', function (ConfigurationManager $configurationManager) { $configurationManager->registerConfigurationType('NodeTypes', ConfigurationManager::CONFIGURATION_PROCESSING_TYPE_DEFAULT, true); }); $context = $bootstrap->getContext(); if (!$context->isProduction()) { $dispatcher->connect(Sequence::class, 'afterInvokeStep', function ($step) use($bootstrap) { if ($step->getIdentifier() === 'typo3.flow:systemfilemonitor') { $nodeTypeConfigurationFileMonitor = FileMonitor::createFileMonitorAtBoot('TYPO3CR_NodeTypesConfiguration', $bootstrap); $packageManager = $bootstrap->getEarlyInstance(PackageManagerInterface::class); foreach ($packageManager->getActivePackages() as $packageKey => $package) { if ($packageManager->isPackageFrozen($packageKey)) { continue; } if (file_exists($package->getConfigurationPath())) { $nodeTypeConfigurationFileMonitor->monitorDirectory($package->getConfigurationPath(), 'NodeTypes(\\..+)\\.yaml'); } } $nodeTypeConfigurationFileMonitor->monitorDirectory(FLOW_PATH_CONFIGURATION, 'NodeTypes(\\..+)\\.yaml'); $nodeTypeConfigurationFileMonitor->detectChanges(); $nodeTypeConfigurationFileMonitor->shutdownObject(); } }); } }
/** * @return string */ public function render() { $configuration = array('window.T3Configuration = {};', 'window.T3Configuration.UserInterface = ' . json_encode($this->settings['userInterface']) . ';', 'window.T3Configuration.nodeTypes = {};', 'window.T3Configuration.nodeTypes.groups = ' . json_encode($this->getNodeTypeGroupsSettings()) . ';', 'window.T3Configuration.requirejs = {};', 'window.T3Configuration.neosStaticResourcesBaseUri = ' . json_encode($this->resourceManager->getPublicPackageResourceUri('Neos.Neos', '')) . ';', 'window.T3Configuration.requirejs.paths = ' . json_encode($this->getRequireJsPathMapping()) . ';', 'window.T3Configuration.maximumFileUploadSize = ' . $this->renderMaximumFileUploadSize()); $neosJavaScriptBasePath = $this->getStaticResourceWebBaseUri('resource://Neos.Neos/Public/JavaScript'); $configuration[] = 'window.T3Configuration.neosJavascriptBasePath = ' . json_encode($neosJavaScriptBasePath) . ';'; if ($this->backendAssetsUtility->shouldLoadMinifiedJavascript()) { $configuration[] = 'window.T3Configuration.neosJavascriptVersion = ' . json_encode($this->backendAssetsUtility->getJavascriptBuiltVersion()) . ';'; } if ($this->bootstrap->getContext()->isDevelopment()) { $configuration[] = 'window.T3Configuration.DevelopmentMode = true;'; } if ($activeDomain = $this->domainRepository->findOneByActiveRequest()) { $configuration[] = 'window.T3Configuration.site = "' . $activeDomain->getSite()->getNodeName() . '";'; } return implode("\n", $configuration); }
/** * Returns TRUE if there is a session that can be resumed. * * If a to-be-resumed session was inactive for too long, this function will * trigger the expiration of that session. An expired session cannot be resumed. * * NOTE that this method does a bit more than the name implies: Because the * session info data needs to be loaded, this method stores this data already * so it doesn't have to be loaded again once the session is being used. * * @return boolean * @api */ public function canBeResumed() { if ($this->request === null) { $this->initializeHttpAndCookie($this->bootstrap->getActiveRequestHandler()); } if ($this->sessionCookie === null || $this->request === null || $this->started === true) { return false; } $sessionMetaData = $this->metaDataCache->get($this->sessionCookie->getValue()); if ($sessionMetaData === false) { return false; } $this->lastActivityTimestamp = $sessionMetaData['lastActivityTimestamp']; $this->storageIdentifier = $sessionMetaData['storageIdentifier']; $this->tags = $sessionMetaData['tags']; return !$this->autoExpire(); }
/** * @param array<Command> $commands * @return void */ protected function displayShortHelpForCommands(array $commands) { $commandsByPackagesAndControllers = $this->buildCommandsIndex($commands); foreach ($commandsByPackagesAndControllers as $packageKey => $commandControllers) { $this->outputLine(''); $this->outputLine('PACKAGE "%s":', [strtoupper($packageKey)]); $this->outputLine(str_repeat('-', $this->output->getMaximumLineLength())); foreach ($commandControllers as $commands) { /** @var Command $command */ foreach ($commands as $command) { $description = wordwrap($command->getShortDescription(), $this->output->getMaximumLineLength() - 43, PHP_EOL . str_repeat(' ', 43), true); $shortCommandIdentifier = $this->commandManager->getShortestIdentifierForCommand($command); $compileTimeSymbol = $this->bootstrap->isCompileTimeCommand($shortCommandIdentifier) ? '*' : ''; $this->outputLine('%-2s%-40s %s', [$compileTimeSymbol, $shortCommandIdentifier, $description]); } $this->outputLine(); } } }
/** * Returns the form definitions for the step * * @param FormDefinition $formDefinition * @return void */ protected function buildForm(FormDefinition $formDefinition) { $page1 = $formDefinition->createPage('page1'); $page1->setRenderingOption('header', 'Setup complete'); $congratulations = $page1->createElement('congratulationsSection', 'Neos.Form:Section'); $congratulations->setLabel('Congratulations'); $success = $congratulations->createElement('success', 'Neos.Form:StaticText'); $success->setProperty('text', 'You have successfully installed Neos! If you need help getting started, please refer to the Neos documentation.'); $success->setProperty('elementClassAttribute', 'alert alert-success'); $docs = $congratulations->createElement('docsLink', 'Neos.Setup:LinkElement'); $docs->setLabel('Read the documentation'); $docs->setProperty('href', 'https://neos.readthedocs.org/'); $docs->setProperty('target', '_blank'); $contextEnv = Bootstrap::getEnvironmentConfigurationSetting('FLOW_CONTEXT') ?: 'Development'; $applicationContext = new ApplicationContext($contextEnv); if (!$applicationContext->isProduction()) { $context = $page1->createElement('contextSection', 'Neos.Form:Section'); $context->setLabel('Define application context'); $contextInfo = $context->createElement('contextInfo', 'Neos.Form:StaticText'); $contextInfo->setProperty('text', 'Your Neos installation is currently not running in "Production" context. If you want to experience Neos with its full speed, you should now change your FLOW_CONTEXT environment variable to "Production".'); $contextDocs = $context->createElement('contextDocsLink', 'Neos.Setup:LinkElement'); $contextDocs->setLabel('Read about application contexts'); $contextDocs->setProperty('href', 'http://flowframework.readthedocs.org/en/stable/TheDefinitiveGuide/PartIII/Bootstrapping.html#the-typo3-flow-application-context'); $contextDocs->setProperty('target', '_blank'); } $frontend = $page1->createElement('frontendSection', 'Neos.Form:Section'); $frontend->setLabel('View the site'); $link = $frontend->createElement('link', 'Neos.Setup:LinkElement'); $link->setLabel('Go to the frontend'); $link->setProperty('href', '/'); $link->setProperty('elementClassAttribute', 'btn btn-large btn-primary'); $backend = $page1->createElement('backendSection', 'Neos.Form:Section'); $backend->setLabel('Start editing'); $backendLink = $backend->createElement('backendLink', 'Neos.Setup:LinkElement'); $backendLink->setLabel('Go to the backend'); $backendLink->setProperty('href', '/neos'); $backendLink->setProperty('elementClassAttribute', 'btn btn-large btn-primary'); $loggedOut = $page1->createElement('loggedOut', 'Neos.Form:StaticText'); $loggedOut->setProperty('text', 'You have automatically been logged out for security reasons since this is the final step. Refresh the page to log in again if you missed something.'); $loggedOut->setProperty('elementClassAttribute', 'alert alert-info'); }
/** * Flushes a particular cache by its identifier * * Given a cache identifier, this flushes just that one cache. To find * the cache identifiers, you can use the configuration:show command with * the type set to "Caches". * * Note that this does not have a force-flush option since it's not * meant to remove temporary code data, resulting into a broken state if * code files lack. * * @param string $identifier Cache identifier to flush cache for * @return void * @see neos.flow:cache:flush * @see neos.flow:configuration:show */ public function flushOneCommand($identifier) { if (!$this->cacheManager->hasCache($identifier)) { $this->outputLine('The cache "%s" does not exist.', [$identifier]); $cacheConfigurations = $this->cacheManager->getCacheConfigurations(); $shortestDistance = -1; foreach (array_keys($cacheConfigurations) as $existingIdentifier) { $distance = levenshtein($existingIdentifier, $identifier); if ($distance <= $shortestDistance || $shortestDistance < 0) { $shortestDistance = $distance; $closestIdentifier = $existingIdentifier; } } if (isset($closestIdentifier)) { $this->outputLine('Did you mean "%s"?', [$closestIdentifier]); } $this->quit(1); } $this->cacheManager->getCache($identifier)->flush(); $this->outputLine('Flushed "%s" cache for "%s" context.', [$identifier, $this->bootstrap->getContext()]); $this->sendAndExit(0); }
/** * Refreeze a package * * Refreezes a currently frozen package: all precompiled information is removed * and file monitoring will consider the package exactly once, on the next * request. After that request, the package remains frozen again, just with the * updated data. * * By specifying <b>all</b> as a package key, all currently frozen packages are * refrozen (the default). * * @param string $packageKey Key of the package to refreeze, or 'all' * @return void * @see neos.flow:package:freeze * @see neos.flow:cache:flush */ public function refreezeCommand($packageKey = 'all') { if (!$this->bootstrap->getContext()->isDevelopment()) { $this->outputLine('Package freezing is only supported in Development context.'); $this->quit(3); } $packagesToRefreeze = []; if ($packageKey === 'all') { foreach (array_keys($this->packageManager->getAvailablePackages()) as $packageKey) { if ($this->packageManager->isPackageFrozen($packageKey)) { $packagesToRefreeze[] = $packageKey; } } if ($packagesToRefreeze === []) { $this->outputLine('Nothing to do, no packages were frozen.'); $this->quit(0); } } else { if ($packageKey === null) { $this->outputLine('You must specify a package to refreeze.'); $this->quit(1); } if (!$this->packageManager->isPackageAvailable($packageKey)) { $this->outputLine('Package "%s" is not available.', [$packageKey]); $this->quit(2); } if (!$this->packageManager->isPackageFrozen($packageKey)) { $this->outputLine('Package "%s" was not frozen.', [$packageKey]); $this->quit(0); } $packagesToRefreeze = [$packageKey]; } foreach ($packagesToRefreeze as $packageKey) { $this->packageManager->refreezePackage($packageKey); $this->outputLine('Refroze package "%s".', [$packageKey]); } Scripts::executeCommand('neos.flow:cache:flush', $this->settings, false); $this->sendAndExit(0); }
/** * Detects and returns the website's absolute base URI * * @return string The resolved resource base URI, @see getResourcesBaseUri() * @throws TargetException if the baseUri can't be resolved */ protected function detectResourcesBaseUri() { if ($this->baseUri !== '' && ($this->baseUri[0] === '/' || strpos($this->baseUri, '://') !== false)) { return $this->baseUri; } $requestHandler = $this->bootstrap->getActiveRequestHandler(); if ($requestHandler instanceof HttpRequestHandlerInterface) { return $requestHandler->getHttpRequest()->getBaseUri() . $this->baseUri; } if ($this->httpBaseUri === null) { throw new TargetException(sprintf('The base URI for resources could not be detected. Please specify the "Neos.Flow.http.baseUri" setting or use an absolute "baseUri" option for target "%s".', $this->name), 1438093977); } return $this->httpBaseUri . $this->baseUri; }
/** * 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; }
/** * Invokes custom PHP code directly after the package manager has been initialized. * * @param \Neos\Flow\Core\Bootstrap $bootstrap The current bootstrap * @return void */ public function boot(\Neos\Flow\Core\Bootstrap $bootstrap) { $bootstrap->registerRequestHandler(new \Neos\Setup\Core\RequestHandler($bootstrap)); }
/** * @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'); }
/** * @param Bootstrap $bootstrap The current bootstrap * @return void */ public function boot(Bootstrap $bootstrap) { $dispatcher = $bootstrap->getSignalSlotDispatcher(); $dispatcher->connect(Workspace::class, 'beforeNodePublishing', NodeRedirectService::class, 'createRedirectsForPublishedNode'); }
/** * @param Bootstrap $bootstrap The current bootstrap * @return void */ public function boot(Bootstrap $bootstrap) { $dispatcher = $bootstrap->getSignalSlotDispatcher(); $dispatcher->connect(AssetService::class, 'assetCreated', ThumbnailGenerator::class, 'createThumbnails'); }
<?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('') => ['' == '@']];
<?php /* * This file is part of the Neos.Flow package. * * (c) Contributors of the Neos Project - www.neos.io * * This package is Open Source Software. For the full copyright and license * information, please view the LICENSE file which was distributed with this * source code. */ $rootPath = isset($_SERVER['FLOW_ROOTPATH']) ? $_SERVER['FLOW_ROOTPATH'] : false; if ($rootPath === false && isset($_SERVER['REDIRECT_FLOW_ROOTPATH'])) { $rootPath = $_SERVER['REDIRECT_FLOW_ROOTPATH']; } if ($rootPath === false) { $rootPath = dirname(__FILE__) . '/../'; } elseif (substr($rootPath, -1) !== '/') { $rootPath .= '/'; } require $rootPath . 'Packages/Framework/Neos.Flow/Classes/Core/Bootstrap.php'; $context = \Neos\Flow\Core\Bootstrap::getEnvironmentConfigurationSetting('FLOW_CONTEXT') ?: 'Development'; $bootstrap = new \Neos\Flow\Core\Bootstrap($context); $bootstrap->run();
/** * Initialize the stream wrappers. * * @param Bootstrap $bootstrap * @return void */ public static function initializeResources(Bootstrap $bootstrap) { StreamWrapperAdapter::initializeStreamWrapper($bootstrap->getObjectManager()); }