/** * Creates the mocked filesystem used in the tests */ public function setUp() { vfsStream::setup('Foo'); $this->mockEnvironment = $this->getMock('TYPO3\\Flow\\Utility\\Environment', array(), array(), '', FALSE); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://Foo/')); $this->mockEnvironment->expects($this->any())->method('getMaximumPathLength')->will($this->returnValue(1024)); }
/** * Factory method which creates an EntityManager. * * @return \Doctrine\ORM\EntityManager */ public function create() { $config = new \Doctrine\ORM\Configuration(); $config->setClassMetadataFactoryName('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\ClassMetadataFactory'); $cache = new \TYPO3\Flow\Persistence\Doctrine\CacheAdapter(); // must use ObjectManager in compile phase... $cache->setCache($this->objectManager->get('TYPO3\\Flow\\Cache\\CacheManager')->getCache('Flow_Persistence_Doctrine')); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $resultCache = new \TYPO3\Flow\Persistence\Doctrine\CacheAdapter(); // must use ObjectManager in compile phase... $resultCache->setCache($this->objectManager->get('TYPO3\\Flow\\Cache\\CacheManager')->getCache('Flow_Persistence_Doctrine_Results')); $config->setResultCacheImpl($resultCache); if (class_exists($this->settings['doctrine']['sqlLogger'])) { $config->setSQLLogger(new $this->settings['doctrine']['sqlLogger']()); } $eventManager = $this->buildEventManager(); $flowAnnotationDriver = $this->objectManager->get('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\Driver\\FlowAnnotationDriver'); $config->setMetadataDriverImpl($flowAnnotationDriver); $proxyDirectory = \TYPO3\Flow\Utility\Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'Doctrine/Proxies')); \TYPO3\Flow\Utility\Files::createDirectoryRecursively($proxyDirectory); $config->setProxyDir($proxyDirectory); $config->setProxyNamespace('TYPO3\\Flow\\Persistence\\Doctrine\\Proxies'); $config->setAutoGenerateProxyClasses(FALSE); $entityManager = \Doctrine\ORM\EntityManager::create($this->settings['backendOptions'], $config, $eventManager); $flowAnnotationDriver->setEntityManager($entityManager); \Doctrine\DBAL\Types\Type::addType('objectarray', 'TYPO3\\Flow\\Persistence\\Doctrine\\DataTypes\\ObjectArray'); if (isset($this->settings['doctrine']['filters']) && is_array($this->settings['doctrine']['filters'])) { foreach ($this->settings['doctrine']['filters'] as $filterName => $filterClass) { $config->addFilter($filterName, $filterClass); $entityManager->getFilters()->enable($filterName); } } return $entityManager; }
/** * @test * @expectedException \TYPO3\Flow\Cache\Exception */ public function setCacheThrowsExceptionOnNonWritableDirectory() { $this->mockEnvironment = $this->getMockBuilder(\TYPO3\Flow\Utility\Environment::class)->disableOriginalConstructor()->getMock(); $this->mockEnvironment->expects($this->any())->method('getMaximumPathLength')->will($this->returnValue(1024)); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://non/existing/directory')); $this->getSimpleFileBackend(); }
public function setUp() { $this->mockDirectory = vfsStream::setup('WritableFileSystemStorageTest'); $this->writableFileSystemStorage = $this->getAccessibleMock(WritableFileSystemStorage::class, null, ['testStorage', ['path' => 'vfs://WritableFileSystemStorageTest/']]); $this->mockEnvironment = $this->getMockBuilder(Environment::class)->disableOriginalConstructor()->getMock(); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://WritableFileSystemStorageTest/')); $this->inject($this->writableFileSystemStorage, 'environment', $this->mockEnvironment); }
/** * @Flow\Around("method(TYPO3\Neos\Domain\Repository\DomainRepository->findOneByActiveRequest())") * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point * @return mixed */ public function cacheDomainForActiveRequest(JoinPointInterface $joinPoint) { if ($this->domainForActiveRequest === FALSE || $this->environment->getContext()->isTesting()) { $domain = $joinPoint->getAdviceChain()->proceed($joinPoint); $this->domainForActiveRequest = $domain; } return $this->domainForActiveRequest; }
/** * Creates the mocked filesystem used in the tests */ public function setUp() { vfsStream::setup('Foo'); $this->mockEnvironment = $this->getMock(\TYPO3\Flow\Utility\Environment::class, array(), array(), '', FALSE); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://Foo/')); $this->mockEnvironment->expects($this->any())->method('getMaximumPathLength')->will($this->returnValue(1024)); $this->mockCacheManager = $this->getMock(\TYPO3\Flow\Cache\CacheManager::class, array('registerCache'), array(), '', FALSE); $this->mockCacheManager->expects($this->any())->method('isCachePersistent')->will($this->returnValue(FALSE)); }
/** * Creates the mocked filesystem used in the tests */ public function setUp() { vfsStream::setup('Foo'); $this->mockEnvironment = $this->getMockBuilder(\TYPO3\Flow\Utility\Environment::class)->disableOriginalConstructor()->getMock(); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://Foo/')); $this->mockEnvironment->expects($this->any())->method('getMaximumPathLength')->will($this->returnValue(1024)); $this->mockCacheManager = $this->getMockBuilder(\TYPO3\Flow\Cache\CacheManager::class)->disableOriginalConstructor()->setMethods(array('registerCache', 'isCachePersistent'))->getMock(); $this->mockCacheManager->expects($this->any())->method('isCachePersistent')->will($this->returnValue(false)); }
/** * Initializes the controller */ protected function initializeAction() { $context = $this->env->getContext(); if ($context == 'Development') { $this->context = 'DEV'; } else { $this->context = 'PRD'; } }
/** * Initializes the manager * * @return void */ public function initializeObject() { $this->lockPathAndFilename = $this->environment->getPathToTemporaryDirectory() . 'Flow.lock'; if (file_exists($this->lockPathAndFilename)) { if (filemtime($this->lockPathAndFilename) < time() - self::LOCKFILE_MAXIMUM_AGE) { unlink($this->lockPathAndFilename); } else { $this->siteLocked = TRUE; } } }
/** * Handle an exception depending on the context with an HTML message or XML comment * * @param array $typoScriptPath path causing the exception * @param \Exception $exception exception to handle * @param integer $referenceCode * @return string */ protected function handle($typoScriptPath, \Exception $exception, $referenceCode) { $context = $this->environment->getContext(); if ($context->isDevelopment()) { $handler = new HtmlMessageHandler(); } else { $handler = new XmlCommentHandler(); } $handler->setRuntime($this->getRuntime()); return $handler->handleRenderingException($typoScriptPath, $exception); }
/** * Initializes the controller */ protected function initializeAction() { $context = $this->env->getContext(); if ($context == 'Development') { $this->context = 'DEV'; } else { $this->context = 'PRD'; } $this->connection = new Es\ElasticSearchConnection(); $this->connection->init(); }
public function setUp() { vfsStream::setup('Foo'); $this->cacheManager = new \TYPO3\Flow\Cache\CacheManager(); $this->mockEnvironment = $this->getMockBuilder(\TYPO3\Flow\Utility\Environment::class)->disableOriginalConstructor()->getMock(); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://Foo/')); $this->cacheManager->injectEnvironment($this->mockEnvironment); $this->mockSystemLogger = $this->getMock(\TYPO3\Flow\Log\SystemLoggerInterface::class); $this->cacheManager->injectSystemLogger($this->mockSystemLogger); $this->mockConfigurationManager = $this->getMockBuilder(\TYPO3\Flow\Configuration\ConfigurationManager::class)->disableOriginalConstructor()->getMock(); $this->cacheManager->injectConfigurationManager($this->mockConfigurationManager); }
/** * Initializes the controller */ protected function initializeAction() { date_default_timezone_set('UTC'); $context = $this->env->getContext(); if ($context == 'Development') { $this->context = 'DEV'; } else { $this->context = 'PRD'; } $this->connection = new Es\ElasticSearchConnection(); $this->connection->init(); $this->sprintConfig = $this->ConfigurationManager->getConfiguration('Sprints'); }
protected function initializeAction() { date_default_timezone_set('UTC'); $this->connection = new Es\ElasticSearchConnection(); $this->connection->init(); $context = $this->env->getContext(); if ($context == 'Development') { $this->context = 'DEV'; } else { $this->context = 'PRD'; } if (isset($_GET['page'])) { $this->currentPage = intval($_GET['page']); } }
/** * Verifies the authentication token. * * @param string $authenticationHash * @param string $parameters * */ private function verifyAuthentication($authenticationHash, $parameters) { if (md5($this->settings['webserviceKey'] . $parameters) == $authenticationHash || $this->environment->getContext() == 'Development') { return TRUE; } return FALSE; }
/** * Saves the current configuration into a cache file and creates a cache inclusion script * in the context's Configuration directory. * * @return void * @throws Exception */ protected function saveConfigurationCache() { $configurationCachePath = $this->environment->getPathToTemporaryDirectory() . 'Configuration/'; if (!file_exists($configurationCachePath)) { Files::createDirectoryRecursively($configurationCachePath); } $cachePathAndFilename = $configurationCachePath . str_replace('/', '_', (string) $this->context) . 'Configurations.php'; $flowRootPath = FLOW_PATH_ROOT; $includeCachedConfigurationsCode = <<<EOD <?php if (FLOW_PATH_ROOT !== '{$flowRootPath}' || !file_exists('{$cachePathAndFilename}')) { \tunlink(__FILE__); \treturn array(); } return require '{$cachePathAndFilename}'; EOD; file_put_contents($cachePathAndFilename, '<?php return ' . var_export($this->configurations, TRUE) . ';'); if (!is_dir(dirname($this->includeCachedConfigurationsPathAndFilename)) && !is_link(dirname($this->includeCachedConfigurationsPathAndFilename))) { Files::createDirectoryRecursively(dirname($this->includeCachedConfigurationsPathAndFilename)); } file_put_contents($this->includeCachedConfigurationsPathAndFilename, $includeCachedConfigurationsCode); if (!file_exists($this->includeCachedConfigurationsPathAndFilename)) { throw new Exception(sprintf('Could not write configuration cache file "%s". Check file permissions for the parent directory.', $this->includeCachedConfigurationsPathAndFilename), 1323339284); } }
/** * Gets the patch as zip package from gerrit * * @param int $patchId * @return bool|string * @throws \TYPO3\Flow\Utility\Exception */ public function getPatchFromGerrit($patchId) { $uri = sprintf($this->gerritApiPattern, $patchId, 'revisions/current/patch?zip'); $outputDirectory = Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'GerritPatches')); Files::createDirectoryRecursively($outputDirectory); $outputZipFilePath = Files::concatenatePaths(array($outputDirectory, $patchId . '.zip')); $httpClient = new Client(); $httpClient->get($uri)->setResponseBody($outputZipFilePath)->send(); $zip = new \ZipArchive(); $zip->open($outputZipFilePath); $patchFile = $zip->getNameIndex(0); $zip->extractTo($outputDirectory); $zip->close(); Files::unlink($outputZipFilePath); return Files::concatenatePaths(array($outputDirectory, $patchFile)); }
/** * @test * @expectedException \TYPO3\Flow\Cache\Exception */ public function setCacheThrowsExceptionIfCachePathLengthExceedsMaximumPathLength() { $this->mockEnvironment = $this->getMockBuilder('TYPO3\\Flow\\Utility\\Environment')->disableOriginalConstructor()->getMock(); $this->mockEnvironment->expects($this->any())->method('getMaximumPathLength')->will($this->returnValue(5)); $this->mockEnvironment->expects($this->any())->method('getPathToTemporaryDirectory')->will($this->returnValue('vfs://Temporary/Directory/')); $this->getSimpleFileBackend(); }
/** * Creates a Doctrine ODM DocumentManager * * @return \Doctrine\ODM\CouchDB\DocumentManager */ public function create() { if (isset($this->documentManager)) { return $this->documentManager; } $httpClient = new \Doctrine\CouchDB\HTTP\SocketClient($this->settings['host'], $this->settings['port'], $this->settings['username'], $this->settings['password'], $this->settings['ip']); $reader = new \Doctrine\Common\Annotations\AnnotationReader(); $metaDriver = new \Doctrine\ODM\CouchDB\Mapping\Driver\AnnotationDriver($reader); $config = new \Doctrine\ODM\CouchDB\Configuration(); $config->setMetadataDriverImpl($metaDriver); $packages = $this->packageManager->getActivePackages(); foreach ($packages as $package) { $designDocumentRootPath = \TYPO3\Flow\Utility\Files::concatenatePaths(array($package->getPackagePath(), 'Migrations/CouchDB/DesignDocuments')); if (is_dir($designDocumentRootPath)) { $packageDesignDocumentFolders = glob($designDocumentRootPath . '/*'); foreach ($packageDesignDocumentFolders as $packageDesignDocumentFolder) { if (is_dir($packageDesignDocumentFolder)) { $designDocumentName = strtolower(basename($packageDesignDocumentFolder)); $config->addDesignDocument($designDocumentName, 'Radmiraal\\CouchDB\\View\\Migration', array('packageKey' => $package->getPackageKey(), 'path' => $packageDesignDocumentFolder)); } } } } $proxyDirectory = \TYPO3\Flow\Utility\Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'DoctrineODM/Proxies')); \TYPO3\Flow\Utility\Files::createDirectoryRecursively($proxyDirectory); $config->setProxyDir($proxyDirectory); $config->setProxyNamespace('TYPO3\\Flow\\Persistence\\DoctrineODM\\Proxies'); $config->setAutoGenerateProxyClasses(TRUE); $couchClient = new \Doctrine\CouchDB\CouchDBClient($httpClient, $this->settings['databaseName']); $this->documentManager = \Doctrine\ODM\CouchDB\DocumentManager::create($couchClient, $config); return $this->documentManager; }
/** * Explicitly compile proxy classes * * The compile command triggers the proxy class compilation. * Although a compilation run is triggered automatically by Flow, there might * be cases in a production context where a manual compile run is needed. * * @Flow\Internal * @param boolean $force If set, classes will be compiled even though the cache says that everything is up to date. * @return void */ public function compileCommand($force = false) { /** @var VariableFrontend $objectConfigurationCache */ $objectConfigurationCache = $this->cacheManager->getCache('Flow_Object_Configuration'); if ($force === false) { if ($objectConfigurationCache->has('allCompiledCodeUpToDate')) { return; } } /** @var PhpFrontend $classesCache */ $classesCache = $this->cacheManager->getCache('Flow_Object_Classes'); $this->proxyClassCompiler->injectClassesCache($classesCache); $this->aopProxyClassBuilder->injectObjectConfigurationCache($objectConfigurationCache); $this->aopProxyClassBuilder->build(); $this->dependencyInjectionProxyClassBuilder->build(); $classCount = $this->proxyClassCompiler->compile(); $dataTemporaryPath = $this->environment->getPathToTemporaryDirectory(); Files::createDirectoryRecursively($dataTemporaryPath); file_put_contents($dataTemporaryPath . 'AvailableProxyClasses.php', $this->proxyClassCompiler->getStoredProxyClassMap()); $objectConfigurationCache->set('allCompiledCodeUpToDate', true); $classesCacheBackend = $classesCache->getBackend(); if ($this->bootstrap->getContext()->isProduction() && $classesCacheBackend instanceof FreezableBackendInterface) { /** @var FreezableBackendInterface $backend */ $backend = $classesCache->getBackend(); $backend->freeze(); } $this->emitFinishedCompilationRun($classCount); }
/** * 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(); 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); }
/** * Compiles the Doctrine proxy class code using the Doctrine ProxyFactory. * * @return void */ public function compileProxies() { Files::emptyDirectoryRecursively(Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'Doctrine/Proxies'))); /** @var \Doctrine\ORM\Proxy\ProxyFactory $proxyFactory */ $proxyFactory = $this->entityManager->getProxyFactory(); $proxyFactory->generateProxyClasses($this->entityManager->getMetadataFactory()->getAllMetadata()); }
/** * @param FlowResource $originalResource * @param array $adjustments * @return array resource, width, height as keys * @throws ImageFileException * @throws InvalidConfigurationException * @throws \TYPO3\Flow\Resource\Exception */ public function processImage(FlowResource $originalResource, array $adjustments) { $additionalOptions = array(); $adjustmentsApplied = false; // TODO: Special handling for SVG should be refactored at a later point. if ($originalResource->getMediaType() === 'image/svg+xml') { $originalResourceStream = $originalResource->getStream(); $resource = $this->resourceManager->importResource($originalResourceStream, $originalResource->getCollectionName()); fclose($originalResourceStream); $resource->setFilename($originalResource->getFilename()); return ['width' => null, 'height' => null, 'resource' => $resource]; } $resourceUri = $originalResource->createTemporaryLocalCopy(); $resultingFileExtension = $originalResource->getFileExtension(); $transformedImageTemporaryPathAndFilename = $this->environment->getPathToTemporaryDirectory() . uniqid('ProcessedImage-') . '.' . $resultingFileExtension; if (!file_exists($resourceUri)) { throw new ImageFileException(sprintf('An error occurred while transforming an image: the resource data of the original image does not exist (%s, %s).', $originalResource->getSha1(), $resourceUri), 1374848224); } $imagineImage = $this->imagineService->open($resourceUri); if ($this->imagineService instanceof \Imagine\Imagick\Imagine && $originalResource->getFileExtension() === 'gif' && $this->isAnimatedGif(file_get_contents($resourceUri)) === true) { $imagineImage->layers()->coalesce(); $layers = $imagineImage->layers(); $newLayers = array(); foreach ($layers as $index => $imagineFrame) { $imagineFrame = $this->applyAdjustments($imagineFrame, $adjustments, $adjustmentsApplied); $newLayers[] = $imagineFrame; } $imagineImage = array_shift($newLayers); $layers = $imagineImage->layers(); foreach ($newLayers as $imagineFrame) { $layers->add($imagineFrame); } $additionalOptions['animated'] = true; } else { $imagineImage = $this->applyAdjustments($imagineImage, $adjustments, $adjustmentsApplied); } if ($adjustmentsApplied === true) { $imagineImage->save($transformedImageTemporaryPathAndFilename, $this->getOptionsMergedWithDefaults($additionalOptions)); $imageSize = $imagineImage->getSize(); // TODO: In the future the collectionName of the new resource should be configurable. $resource = $this->resourceManager->importResource($transformedImageTemporaryPathAndFilename, $originalResource->getCollectionName()); if ($resource === false) { throw new ImageFileException('An error occurred while importing a generated image file as a resource.', 1413562208); } unlink($transformedImageTemporaryPathAndFilename); $pathInfo = UnicodeFunctions::pathinfo($originalResource->getFilename()); $resource->setFilename(sprintf('%s-%ux%u.%s', $pathInfo['filename'], $imageSize->getWidth(), $imageSize->getHeight(), $pathInfo['extension'])); } else { $originalResourceStream = $originalResource->getStream(); $resource = $this->resourceManager->importResource($originalResourceStream, $originalResource->getCollectionName()); fclose($originalResourceStream); $resource->setFilename($originalResource->getFilename()); $imageSize = $this->getImageSize($originalResource); $imageSize = new Box($imageSize['width'], $imageSize['height']); } $this->imageSizeCache->set($resource->getCacheEntryIdentifier(), array('width' => $imageSize->getWidth(), 'height' => $imageSize->getHeight())); $result = array('width' => $imageSize->getWidth(), 'height' => $imageSize->getHeight(), 'resource' => $resource); return $result; }
/** * renders the exception to nice html content element to display, edit, remove, ... * * @param string $typoScriptPath - path causing the exception * @param \Exception $exception - exception to handle * @param integer $referenceCode - might be unset * @return string */ protected function handle($typoScriptPath, \Exception $exception, $referenceCode) { $handler = new ContextDependentHandler(); $handler->setRuntime($this->runtime); $output = $handler->handleRenderingException($typoScriptPath, $exception); $currentContext = $this->getRuntime()->getCurrentContext(); if (isset($currentContext['node'])) { /** @var NodeInterface $node */ $node = $currentContext['node']; $applicationContext = $this->environment->getContext(); if ($applicationContext->isProduction() && $this->privilegeManager->isPrivilegeTargetGranted('TYPO3.Neos:Backend.GeneralAccess') && $node->getContext()->getWorkspaceName() !== 'live') { $output = '<div class="neos-rendering-exception"><div class="neos-rendering-exception-title">Failed to render element' . $output . '</div></div>'; } return $this->contentElementWrappingService->wrapContentObject($node, $output, $typoScriptPath); } return $output; }
/** * @param string $sitePackage * @param string $siteName * @param string $baseDomain * @return Site */ public function importSiteFromTemplate($sitePackage, $siteName, $baseDomain = '') { if (empty($baseDomain)) { $request = Request::createFromEnvironment(); $baseDomain = $request->getBaseUri()->getHost(); } $siteTemplate = new StandaloneView(); $siteTemplate->setTemplatePathAndFilename(FLOW_PATH_PACKAGES . 'Sites/' . $sitePackage . '/Resources/Private/Templates/Content/Sites.xml'); $siteTemplate->assignMultiple(['siteName' => $siteName, 'siteNodeName' => \TYPO3\TYPO3CR\Utility::renderValidNodeName($siteName), 'packageKey' => $sitePackage]); $generatedSiteImportXmlContent = $siteTemplate->render(); $dataTemporaryPath = $this->environment->getPathToTemporaryDirectory(); $temporarySiteXml = $dataTemporaryPath . uniqid($siteName) . '.xml'; file_put_contents($temporarySiteXml, $generatedSiteImportXmlContent); $site = $this->siteImportService->importFromFile($temporarySiteXml); $domain = new Domain(); $domain->setActive(true); $domain->setSite($site); $domain->setHostPattern(\TYPO3\TYPO3CR\Utility::renderValidNodeName($siteName) . '.' . $baseDomain); $this->domainRepository->add($domain); return $site; }
/** * Flushes all registered caches * * @param boolean $flushPersistentCaches If set to TRUE, even those caches which are flagged as "persistent" will be flushed * @return void * @api */ public function flushCaches($flushPersistentCaches = FALSE) { $this->createAllCaches(); /** @var FrontendInterface $cache */ foreach ($this->caches as $identifier => $cache) { if (!$flushPersistentCaches && $this->isCachePersistent($identifier)) { continue; } $cache->flush(); } $this->configurationManager->flushConfigurationCache(); $dataTemporaryPath = $this->environment->getPathToTemporaryDirectory(); Files::unlink($dataTemporaryPath . 'AvailableProxyClasses.php'); }
/** * Builds the URI * * @param array $arguments optional URI arguments. Will be merged with $this->arguments with precedence to $arguments * @return string The URI * @api */ public function build(array $arguments = array()) { $arguments = Arrays::arrayMergeRecursiveOverrule($this->arguments, $arguments); $arguments = $this->mergeArgumentsWithRequestArguments($arguments); $uri = $this->router->resolve($arguments); $this->lastArguments = $arguments; if (!$this->environment->isRewriteEnabled()) { $uri = 'index.php/' . $uri; } $httpRequest = $this->request->getHttpRequest(); if ($this->createAbsoluteUri === true) { $uri = $httpRequest->getBaseUri() . $uri; } elseif (!$this->createRelativePaths) { $uri = $httpRequest->getScriptRequestPath() . $uri; } if ($this->section !== '') { $uri .= '#' . $this->section; } return $uri; }
/** * Prepare an uploaded file to be imported as resource object. Will check the validity of the file, * move it outside of upload folder if open_basedir is enabled and check the filename. * * @param array $uploadInfo * @return array Array of string with the two keys "filepath" (the path to get the filecontent from) and "filename" the filename of the originally uploaded file. * @throws Exception */ protected function prepareUploadedFileForImport(array $uploadInfo) { $openBasedirEnabled = (bool) ini_get('open_basedir'); $temporaryTargetPathAndFilename = $uploadInfo['tmp_name']; $pathInfo = UnicodeFunctions::pathinfo($uploadInfo['name']); if (!is_uploaded_file($temporaryTargetPathAndFilename)) { throw new Exception('The given upload file "' . strip_tags($pathInfo['basename']) . '" was not uploaded through PHP. As it could pose a security risk it cannot be imported.', 1422461503); } if ($openBasedirEnabled === TRUE) { // Move uploaded file to a readable folder before trying to read sha1 value of file $newTemporaryTargetPathAndFilename = $this->environment->getPathToTemporaryDirectory() . 'ResourceUpload.' . uniqid() . '.tmp'; if (move_uploaded_file($temporaryTargetPathAndFilename, $newTemporaryTargetPathAndFilename) === FALSE) { throw new Exception(sprintf('The uploaded file "%s" could not be moved to the temporary location "%s".', $temporaryTargetPathAndFilename, $newTemporaryTargetPathAndFilename), 1375199056); } $temporaryTargetPathAndFilename = $newTemporaryTargetPathAndFilename; } if (!is_file($temporaryTargetPathAndFilename)) { throw new Exception(sprintf('The temporary file "%s" of the file upload does not exist (anymore).', $temporaryTargetPathAndFilename), 1375198998); } return array('filepath' => $temporaryTargetPathAndFilename, 'filename' => $pathInfo['basename']); }
/** * Returns the publish path and filename to be used to publish the specified persistent resource * * @Flow\Around("method(TYPO3\Flow\Resource\Publishing\FileSystemPublishingTarget->buildPersistentResourcePublishPathAndFilename()) && setting(TYPO3.Flow.security.enable)") * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point * @return mixed Result of the target method */ public function rewritePersistentResourcePublishPathAndFilenameForPrivateResources(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint) { $resource = $joinPoint->getMethodArgument('resource'); /** @var $configuration \TYPO3\Flow\Security\Authorization\Resource\SecurityPublishingConfiguration */ $configuration = $resource->getPublishingConfiguration(); $returnFilename = $joinPoint->getMethodArgument('returnFilename'); if ($configuration === NULL || $configuration instanceof \TYPO3\Flow\Security\Authorization\Resource\SecurityPublishingConfiguration === FALSE) { return $joinPoint->getAdviceChain()->proceed($joinPoint); } $publishingPath = FALSE; $allowedRoles = $configuration->getAllowedRoles(); if (count(array_intersect($allowedRoles, $this->securityContext->getRoles())) > 0) { $publishingPath = \TYPO3\Flow\Utility\Files::concatenatePaths(array($joinPoint->getProxy()->getResourcesPublishingPath(), 'Persistent/', $this->session->getID())) . '/'; $filename = $resource->getResourcePointer()->getHash() . '.' . $resource->getFileExtension(); \TYPO3\Flow\Utility\Files::createDirectoryRecursively($publishingPath); $this->accessRestrictionPublisher->publishAccessRestrictionsForPath($publishingPath); if ($this->settings['resource']['publishing']['fileSystem']['mirrorMode'] === 'link') { foreach ($allowedRoles as $role) { $roleDirectory = \TYPO3\Flow\Utility\Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'PrivateResourcePublishing/', $role)); \TYPO3\Flow\Utility\Files::createDirectoryRecursively($roleDirectory); if (file_exists($publishingPath . $role)) { if (\TYPO3\Flow\Utility\Files::is_link(\TYPO3\Flow\Utility\Files::concatenatePaths(array($publishingPath, $role))) && realpath(\TYPO3\Flow\Utility\Files::concatenatePaths(array($publishingPath, $role))) === $roleDirectory) { continue; } unlink($publishingPath . $role); symlink($roleDirectory, \TYPO3\Flow\Utility\Files::concatenatePaths(array($publishingPath, $role))); } else { symlink($roleDirectory, \TYPO3\Flow\Utility\Files::concatenatePaths(array($publishingPath, $role))); } } $publishingPath = \TYPO3\Flow\Utility\Files::concatenatePaths(array($publishingPath, $allowedRoles[0])) . '/'; } if ($returnFilename === TRUE) { $publishingPath = \TYPO3\Flow\Utility\Files::concatenatePaths(array($publishingPath, $filename)); } } return $publishingPath; }
/** * Imports a resource (file) as specified in the given upload info array as a * persistent resource. * * On a successful import this method returns a Resource object representing * the newly imported persistent resource. * * @param array $uploadInfo An array detailing the resource to import (expected keys: name, tmp_name) * @param string $collectionName Name of the collection this uploaded resource should be part of * @return string A resource object representing the imported resource * @throws Exception * @api */ public function importUploadedResource(array $uploadInfo, $collectionName) { $pathInfo = pathinfo($uploadInfo['name']); $originalFilename = $pathInfo['basename']; $sourcePathAndFilename = $uploadInfo['tmp_name']; if (!file_exists($sourcePathAndFilename)) { throw new Exception(sprintf('The temporary file "%s" of the file upload does not exist (anymore).', $sourcePathAndFilename), 1428909075); } $newSourcePathAndFilename = $this->environment->getPathToTemporaryDirectory() . 'Flownative_Aws_S3_' . uniqid() . '.tmp'; if (move_uploaded_file($sourcePathAndFilename, $newSourcePathAndFilename) === false) { throw new Exception(sprintf('The uploaded file "%s" could not be moved to the temporary location "%s".', $sourcePathAndFilename, $newSourcePathAndFilename), 1428909076); } $sha1Hash = sha1_file($newSourcePathAndFilename); $md5Hash = md5_file($newSourcePathAndFilename); $resource = new Resource(); $resource->setFilename($originalFilename); $resource->setCollectionName($collectionName); $resource->setFileSize(filesize($newSourcePathAndFilename)); $resource->setSha1($sha1Hash); $resource->setMd5($md5Hash); $this->s3Client->putObject(array('Bucket' => $this->bucketName, 'Body' => fopen($newSourcePathAndFilename, 'rb'), 'ContentLength' => $resource->getFileSize(), 'ContentType' => $resource->getMediaType(), 'Key' => $this->keyPrefix . $sha1Hash)); return $resource; }