/**
* 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(\TYPO3\Flow\SignalSlot\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(\TYPO3\Flow\Object\ObjectManagerInterface::class);
$this->mockBootstrap->expects($this->any())->method('getObjectManager')->will($this->returnValue($mockObjectManager));
$mockReflectionService = $this->createMock(\TYPO3\Flow\Reflection\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(\TYPO3\Flow\Reflection\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 = array('typo3/flow' => 'TYPO3.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);
}
/**
* @param string $path
* @return string
* @throws \Exception
*/
public function render($path = NULL)
{
if ($path === NULL) {
$path = '404';
}
/** @var RequestHandler $activeRequestHandler */
$activeRequestHandler = $this->bootstrap->getActiveRequestHandler();
$parentHttpRequest = $activeRequestHandler->getHttpRequest();
$requestPath = $parentHttpRequest->getUri()->getPath();
$language = explode('/', ltrim($requestPath, '/'))[0];
if ($language === 'neos') {
throw new \Exception('NotFoundViewHelper can not be used for neos-routes.', 1435648210);
}
$language = $this->localeDetector->detectLocaleFromLocaleTag($language)->getLanguage();
if ($this->contentDimensionPresetSource->findPresetByUriSegment('language', $language) === NULL) {
$language = '';
}
if ($language !== '') {
$language .= '/';
}
$request = Request::create(new Uri(rtrim($parentHttpRequest->getBaseUri(), '/') . '/' . $language . $path));
$matchingRoute = $this->router->route($request);
if (!$matchingRoute) {
throw new \Exception(sprintf('Uri with path "%s" could not be found.', rtrim($parentHttpRequest->getBaseUri(), '/') . '/' . $language . $path), 1426446160);
}
$response = new Response();
$objectManager = $this->bootstrap->getObjectManager();
$baseComponentChain = $objectManager->get('TYPO3\\Flow\\Http\\Component\\ComponentChain');
$componentContext = new ComponentContext($request, $response);
$baseComponentChain->handle($componentContext);
return $response->getContent();
}
/**
* 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('TYPO3\\Flow\\Core\\Booting\\Sequence', 'afterInvokeStep', function ($step) use($bootstrap, $dispatcher) {
if ($step->getIdentifier() === 'typo3.flow:systemfilemonitor') {
$typoScriptFileMonitor = \TYPO3\Flow\Monitor\FileMonitor::createFileMonitorAtBoot('TypoScript_Files', $bootstrap);
$packageManager = $bootstrap->getEarlyInstance('TYPO3\\Flow\\Package\\PackageManagerInterface');
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('TYPO3\\Flow\\Cache\\CacheManager');
$listener = new \TYPO3\TypoScript\Core\Cache\FileMonitorListener($cacheManager);
$dispatcher->connect('TYPO3\\Flow\\Monitor\\FileMonitor', 'filesHaveChanged', $listener, 'flushContentCacheOnFileChanges');
}
});
}
}
/**
* 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();
$requestHandler->setHttpRequest($httpRequest);
$requestHandler->setHttpResponse($response);
$objectManager = $this->bootstrap->getObjectManager();
$baseComponentChain = $objectManager->get(\TYPO3\Flow\Http\Component\ComponentChain::class);
$componentContext = new ComponentContext($httpRequest, $response);
if (version_compare(PHP_VERSION, '6.0.0') >= 0) {
try {
$baseComponentChain->handle($componentContext);
} catch (\Throwable $throwable) {
$this->prepareErrorResponse($throwable, $response);
}
} else {
try {
$baseComponentChain->handle($componentContext);
} catch (\Exception $exception) {
$this->prepareErrorResponse($exception, $response);
}
}
$session = $this->bootstrap->getObjectManager()->get(\TYPO3\Flow\Session\SessionInterface::class);
if ($session->isStarted()) {
$session->close();
}
return $response;
}
/**
* @param Bootstrap $bootstrap
*/
public function boot(Bootstrap $bootstrap)
{
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$dispatcher->connect('TYPO3\\Flow\\Configuration\\ConfigurationManager', 'configurationManagerReady', function ($configurationManager) {
$configurationManager->registerConfigurationType('Sprints');
});
}
/**
* @param Bootstrap $bootstrap The current bootstrap
* @return void
*/
public function boot(Bootstrap $bootstrap)
{
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$dispatcher->connect('TYPO3\\TYPO3CR\\Domain\\Model\\Node', 'nodeUpdated', 'Nezaniel\\SystemNodes\\Service\\SystemNodeService', 'refreshCacheIfNecessary');
$dispatcher->connect('TYPO3\\TYPO3CR\\Domain\\Model\\Node', 'nodeAdded', 'Nezaniel\\SystemNodes\\Service\\SystemNodeService', 'refreshCacheIfNecessary');
$dispatcher->connect('TYPO3\\TYPO3CR\\Domain\\Model\\Node', 'nodeRemoved', 'Nezaniel\\SystemNodes\\Service\\SystemNodeService', 'refreshCacheIfNecessary');
}
/**
* Boot the package. We wire some signals to slots here.
*
* @param \TYPO3\Flow\Core\Bootstrap $bootstrap The current bootstrap
* @return void
*/
public function boot(\TYPO3\Flow\Core\Bootstrap $bootstrap)
{
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$dispatcher->connect('Lightwerk\\SurfCaptain\\GitApi\\ApiRequest', 'apiCall', 'Lightwerk\\SurfCaptain\\GitApi\\RequestListener', 'saveApiCall');
$dispatcher->connect('Lightwerk\\SurfCaptain\\GitApi\\ApiRequest', 'apiCall', 'Lightwerk\\SurfCaptain\\GitApi\\RequestListener', 'logApiCall');
$dispatcher->connect('Lightwerk\\SurfCaptain\\GitApi\\ApiRequest', 'beforeApiCall', 'Lightwerk\\SurfCaptain\\GitApi\\RequestListener', 'logBeforeApiCall');
}
/**
* @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));
}
/**
* Registers slots for signals in order to be able to index nodes
*
* @param Bootstrap $bootstrap
*/
public function registerExtractionSlot(Bootstrap $bootstrap)
{
$configurationManager = $bootstrap->getObjectManager()->get(ConfigurationManager::class);
$settings = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $this->getPackageKey());
if (isset($settings['realtimeExtraction']['enabled']) && $settings['realtimeExtraction']['enabled'] === TRUE) {
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$dispatcher->connect(Asset::class, 'assetCreated', ExtractionManager::class, 'extractMetaData');
}
}
/**
* @return \TYPO3\Neos\Domain\Model\Domain
*/
public function findOneByActiveRequest()
{
$matchingDomain = null;
$activeRequestHandler = $this->bootstrap->getActiveRequestHandler();
if ($activeRequestHandler instanceof \TYPO3\Flow\Http\HttpRequestHandlerInterface) {
$matchingDomain = $this->findOneByHost($activeRequestHandler->getHttpRequest()->getUri()->getHost(), true);
}
return $matchingDomain;
}
/**
* @param \TYPO3\Flow\Core\Bootstrap $bootstrap
*/
public function prepareRealtimeIndexing(\TYPO3\Flow\Core\Bootstrap $bootstrap)
{
$this->configurationManager = $bootstrap->getObjectManager()->get('TYPO3\\Flow\\Configuration\\ConfigurationManager');
$settings = $this->configurationManager->getConfiguration(\TYPO3\Flow\Configuration\ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $this->getPackageKey());
if (isset($settings['realtimeIndexing']['enabled']) && $settings['realtimeIndexing']['enabled'] === TRUE) {
$bootstrap->getSignalSlotDispatcher()->connect('Flowpack\\ElasticSearch\\Indexer\\Object\\Signal\\SignalEmitter', 'objectUpdated', 'Flowpack\\ElasticSearch\\Indexer\\Object\\ObjectIndexer', 'indexObject');
$bootstrap->getSignalSlotDispatcher()->connect('Flowpack\\ElasticSearch\\Indexer\\Object\\Signal\\SignalEmitter', 'objectPersisted', 'Flowpack\\ElasticSearch\\Indexer\\Object\\ObjectIndexer', 'indexObject');
$bootstrap->getSignalSlotDispatcher()->connect('Flowpack\\ElasticSearch\\Indexer\\Object\\Signal\\SignalEmitter', 'objectRemoved', 'Flowpack\\ElasticSearch\\Indexer\\Object\\ObjectIndexer', 'removeObject');
}
}
/**
* 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();
// HitChat Notifier
$dispatcher->connect('Lightwerk\\SurfRunner\\Service\\DeploymentService', 'deploymentStarted', 'Lightwerk\\SurfRunner\\Notification\\HitChatNotifier', 'deploymentStarted');
$dispatcher->connect('Lightwerk\\SurfRunner\\Service\\DeploymentService', 'deploymentFinished', 'Lightwerk\\SurfRunner\\Notification\\HitChatNotifier', 'deploymentFinished');
// Email Notifier
$dispatcher->connect('Lightwerk\\SurfRunner\\Service\\DeploymentService', 'deploymentStarted', 'Lightwerk\\SurfRunner\\Notification\\EmailNotifier', 'deploymentStarted');
$dispatcher->connect('Lightwerk\\SurfRunner\\Service\\DeploymentService', 'deploymentFinished', 'Lightwerk\\SurfRunner\\Notification\\EmailNotifier', 'deploymentFinished');
}
/**
* @param \TYPO3\Flow\Core\Bootstrap $bootstrap The current bootstrap
* @return void
*/
public function boot(\TYPO3\Flow\Core\Bootstrap $bootstrap)
{
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$dispatcher->connect('TYPO3\\Flow\\Mvc\\Dispatcher', 'afterControllerInvocation', function ($request) use($bootstrap) {
if (!$request instanceof \TYPO3\Flow\Mvc\ActionRequest || $request->getHttpRequest()->isMethodSafe() !== TRUE) {
$bootstrap->getObjectManager()->get('Radmiraal\\CouchDB\\CouchDBHelper')->flush();
}
});
$dispatcher->connect('TYPO3\\Flow\\Cli\\SlaveRequestHandler', 'dispatchedCommandLineSlaveRequest', 'Radmiraal\\CouchDB\\CouchDBHelper', 'flush');
}
/**
* Invokes custom PHP code directly after the package manager has been initialized.
*
* @param \TYPO3\Flow\Core\Bootstrap $bootstrap The current bootstrap
* @return void
*/
public function boot(\TYPO3\Flow\Core\Bootstrap $bootstrap)
{
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$dispatcher->connect('TYPO3\\Flow\\Persistence\\Doctrine\\PersistenceManager', 'allObjectsPersisted', 'TYPO3\\TYPO3CR\\Domain\\Repository\\NodeDataRepository', 'flushNodeRegistry');
$dispatcher->connect('TYPO3\\TYPO3CR\\Domain\\Repository\\NodeDataRepository', 'repositoryObjectsPersisted', 'TYPO3\\TYPO3CR\\Domain\\Repository\\NodeDataRepository', 'flushNodeRegistry');
$dispatcher->connect('TYPO3\\TYPO3CR\\Domain\\Model\\NodeData', 'nodePathChanged', 'TYPO3\\Flow\\Mvc\\Routing\\RouterCachingService', 'flushCaches');
$dispatcher->connect('TYPO3\\Flow\\Configuration\\ConfigurationManager', 'configurationManagerReady', function ($configurationManager) {
$configurationManager->registerConfigurationType('NodeTypes', \TYPO3\Flow\Configuration\ConfigurationManager::CONFIGURATION_PROCESSING_TYPE_DEFAULT);
});
}
/**
* 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();
# Command Auditing
$dispatcher->connect('Flow2Lab\\EventSourcing\\Command\\Bus\\InternalCommandBus', 'commandHandlingSuccess', 'Flow2Lab\\EventSourcing\\Auditing\\CommandLogger', 'onCommandHandlingSuccess');
$dispatcher->connect('Flow2Lab\\EventSourcing\\Command\\Bus\\InternalCommandBus', 'commandHandlingFailure', 'Flow2Lab\\EventSourcing\\Auditing\\CommandLogger', 'onCommandHandlingFailure');
# Event Auditing
$dispatcher->connect('Flow2Lab\\EventSourcing\\Event\\Bus\\InternalEventBus', 'eventHandlingSuccess', 'Flow2Lab\\EventSourcing\\Auditing\\EventLogger', 'onEventHandlingSuccess');
$dispatcher->connect('Flow2Lab\\EventSourcing\\Event\\Bus\\InternalEventBus', 'eventHandlingFailure', 'Flow2Lab\\EventSourcing\\Auditing\\EventLogger', 'onEventHandlingFailure');
$dispatcher->connect('Flow2Lab\\EventSourcing\\Event\\Bus\\InternalEventBus', 'eventQueueingSuccess', 'Flow2Lab\\EventSourcing\\Auditing\\EventLogger', 'onEventQueueingSuccess');
}
/**
* @param Bootstrap $bootstrap The current bootstrap
* @return void
*/
public function boot(Bootstrap $bootstrap)
{
$dispatcher = $bootstrap->getSignalSlotDispatcher();
$dispatcher->connect('TYPO3\\Flow\\Core\\Booting\\Sequence', 'afterInvokeStep', function ($step) use($bootstrap) {
if ($step instanceof \TYPO3\Flow\Core\Booting\Step && $step->getIdentifier() == 'typo3.flow:persistence') {
/** @var \Doctrine\Common\Persistence\ObjectManager $entityManager */
$entityManager = $bootstrap->getObjectManager()->get(\Doctrine\Common\Persistence\ObjectManager::class);
$entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
}
});
}
public function setUp()
{
$this->fileSystemTarget = new FileSystemTarget('test');
$this->mockBootstrap = $this->getMockBuilder(Bootstrap::class)->disableOriginalConstructor()->getMock();
$this->mockRequestHandler = $this->getMockBuilder(HttpRequestHandlerInterface::class)->getMock();
$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);
}
/**
* {@inheritdoc}
*/
public function boot(\TYPO3\Flow\Core\Bootstrap $bootstrap)
{
require_once FLOW_PATH_PACKAGES . '/Libraries/raven/raven/lib/Raven/Autoloader.php';
\Raven_Autoloader::register();
$bootstrap->getSignalSlotDispatcher()->connect('TYPO3\\Flow\\Core\\Booting\\Sequence', 'afterInvokeStep', function ($step, $runlevel) use($bootstrap) {
if ($step->getIdentifier() === 'typo3.flow:objectmanagement:runtime') {
// This triggers the initializeObject method
$bootstrap->getObjectManager()->get('Networkteam\\SentryClient\\ErrorHandler');
}
});
}
/**
* Adds a CSRF token as argument in ExtDirect requests
*
* @Flow\Around("method(TYPO3\ExtJS\ExtDirect\Transaction->buildRequest()) && setting(TYPO3.Flow.security.enable)")
* @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point
* @return \TYPO3\Flow\Mvc\ActionRequest
*/
public function transferCsrfTokenToExtDirectRequests(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint)
{
$extDirectRequest = $joinPoint->getAdviceChain()->proceed($joinPoint);
$requestHandler = $this->bootstrap->getActiveRequestHandler();
if ($requestHandler instanceof \TYPO3\Flow\Http\HttpRequestHandlerInterface) {
$arguments = $requestHandler->getHttpRequest()->getArguments();
if (isset($arguments['__csrfToken'])) {
$requestArguments = $extDirectRequest->getMainRequest()->getArguments();
$requestArguments['__csrfToken'] = $arguments['__csrfToken'];
$extDirectRequest->getMainRequest()->setArguments($requestArguments);
}
}
return $extDirectRequest;
}
/**
* Retrieve current authenticated account
*
* @return \TYPO3\Flow\Security\Account|NULL
*/
public static function getAuthenticatedAccount()
{
self::initializeBootstrap();
if (self::$bootstrap) {
$objectManager = self::$bootstrap->getObjectManager();
if ($objectManager) {
$securityContext = $objectManager->get('\\TYPO3\\Flow\\Security\\Context');
if ($securityContext && $securityContext->canBeInitialized()) {
return $securityContext->getAccount();
}
}
}
return null;
}
/**
* {@inheritdoc}
*/
public function boot(\TYPO3\Flow\Core\Bootstrap $bootstrap)
{
require_once FLOW_PATH_PACKAGES . '/Libraries/raven/raven/lib/Raven/Autoloader.php';
\Raven_Autoloader::register();
$bootstrap->getSignalSlotDispatcher()->connect('TYPO3\\Flow\\Core\\Booting\\Sequence', 'afterInvokeStep', function ($step, $runlevel) use($bootstrap) {
if ($step->getIdentifier() === 'typo3.flow:objectmanagement:runtime') {
// This triggers the initializeObject method
$bootstrap->getObjectManager()->get('Networkteam\\SentryClient\\ErrorHandler');
}
});
// Make Sentry DSN settable via Environment Variables. Only used in context Production/Heroku.
if (getenv('ENV_SENTRY_DSN')) {
define('ENV_SENTRY_DSN', getenv('ENV_SENTRY_DSN'));
}
}
/**
* @return void
*/
public function setUp()
{
parent::setup();
vfsStream::setup('Foo');
$this->httpRequest = Request::create(new Uri('http://localhost'));
$this->httpResponse = new Response();
$mockRequestHandler = $this->createMock(\TYPO3\Flow\Http\RequestHandler::class, array(), array(), '', false, false);
$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(\TYPO3\Flow\Core\Bootstrap::class, array(), array(), '', false, false);
$this->mockBootstrap->expects($this->any())->method('getActiveRequestHandler')->will($this->returnValue($mockRequestHandler));
$this->mockSecurityContext = $this->createMock(\TYPO3\Flow\Security\Context::class, array(), array(), '', false, false);
$this->mockObjectManager = $this->createMock(\TYPO3\Flow\Object\ObjectManagerInterface::class, array(), array(), '', false, false);
$this->mockObjectManager->expects($this->any())->method('get')->with(\TYPO3\Flow\Security\Context::class)->will($this->returnValue($this->mockSecurityContext));
}
/**
* @return void
*/
public function setUp()
{
parent::setup();
vfsStream::setup('Foo');
$this->httpRequest = Request::create(new Uri('http://localhost'));
$this->httpResponse = new Response();
$mockRequestHandler = $this->getMock('TYPO3\\Flow\\Http\\RequestHandler', array(), array(), '', FALSE, FALSE);
$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->getMock('TYPO3\\Flow\\Core\\Bootstrap', array(), array(), '', FALSE, FALSE);
$this->mockBootstrap->expects($this->any())->method('getActiveRequestHandler')->will($this->returnValue($mockRequestHandler));
$this->mockSecurityContext = $this->getMock('TYPO3\\Flow\\Security\\Context', array(), array(), '', FALSE, FALSE);
$this->mockObjectManager = $this->getMock('TYPO3\\Flow\\Object\\ObjectManagerInterface', array(), array(), '', FALSE, FALSE);
$this->mockObjectManager->expects($this->any())->method('get')->with('TYPO3\\Flow\\Security\\Context')->will($this->returnValue($this->mockSecurityContext));
}
/**
* 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;
}
/**
* Resolves a few dependencies of this request handler which can't be resolved
* automatically due to the early stage of the boot process this request handler
* is invoked at.
*
* @return void
*/
protected function resolveDependencies()
{
$objectManager = $this->bootstrap->getObjectManager();
$this->baseComponentChain = $objectManager->get('TYPO3\\Flow\\Http\\Component\\ComponentChain');
$configurationManager = $objectManager->get('TYPO3\\Flow\\Configuration\\ConfigurationManager');
$this->settings = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'TYPO3.Flow');
}
/**
* 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('TYPO3\\Flow\\Cache\\CacheManager')->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 \TYPO3\Flow\Monitor\ChangeDetectionStrategy\ModificationTimeStrategy();
$fileChangeDetector->injectCache($fileMonitorCache);
$bootstrap->getObjectManager()->registerShutdownObject($fileChangeDetector, 'shutdownObject');
$fileMonitor = new FileMonitor($identifier);
$fileMonitor->injectCache($fileMonitorCache);
$fileMonitor->injectChangeDetectionStrategy($fileChangeDetector);
$fileMonitor->injectSignalDispatcher($bootstrap->getEarlyInstance('TYPO3\\Flow\\SignalSlot\\Dispatcher'));
$fileMonitor->injectSystemLogger($bootstrap->getEarlyInstance('TYPO3\\Flow\\Log\\SystemLoggerInterface'));
$fileMonitor->initializeObject();
return $fileMonitor;
}
/**
* 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 typo3.flow:cache:warmup
* @see typo3.flow:package:freeze
* @see typo3.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();
$dataTemporaryPath = $this->environment->getPathToTemporaryDirectory();
\TYPO3\Flow\Utility\Files::unlink($dataTemporaryPath . 'AvailableProxyClasses.php');
$this->outputLine('Flushed all caches for "' . $this->bootstrap->getContext() . '" context.');
if ($this->lockManager->isSiteLocked()) {
$this->lockManager->unlockSite();
}
$frozenPackages = array();
foreach (array_keys($this->packageManager->getActivePackages()) as $packageKey) {
if ($this->packageManager->isPackageFrozen($packageKey)) {
$frozenPackages[] = $packageKey;
}
}
if ($frozenPackages !== array()) {
$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, array(), 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, array($frozenPackages));
}
$this->sendAndExit(0);
}
/**
* @return \TYPO3\Flow\Http\Request
*/
protected function getHttpRequest()
{
$requestHandler = $this->bootstrap->getActiveRequestHandler();
if ($requestHandler instanceof \TYPO3\Flow\Http\HttpRequestHandlerInterface) {
return $requestHandler->getHttpRequest();
}
}
/**
* 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->dispatcher === null) {
$this->dispatcher = $this->bootstrap->getEarlyInstance(Dispatcher::class);
}
$this->dispatcher->dispatch(PackageManager::class, 'packageStatesUpdated');
}
/**
* 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'] === 'TYPO3.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('TYPO3\\Flow\\Package\\PackageManagerInterface')->getPackage('TYPO3.Flow');
$applicationPackage = $this->bootstrap->getEarlyInstance('TYPO3\\Flow\\Package\\PackageManagerInterface')->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'));
}
}
