/**
* Redirects to the Neos backend on the given site, passing a one-time login token
*
* @param Site $site
* @return void
*/
public function switchSiteAction($site)
{
$token = Algorithms::generateRandomToken(32);
$this->loginTokenCache->set($token, $this->currentSession->getId());
$siteUri = $this->linkingService->createSiteUri($this->controllerContext, $site);
$loginUri = $this->controllerContext->getUriBuilder()->reset()->uriFor('tokenLogin', ['token' => $token], 'Login', 'Neos.Neos');
$this->redirectToUri($siteUri . $loginUri);
}
/**
* @return string The current cache version identifier
*/
public function render()
{
$version = $this->configurationCache->get('ConfigurationVersion');
if ($version === false) {
$version = time();
$this->configurationCache->set('ConfigurationVersion', (string) $version);
}
return $version;
}
/**
* Set up test dependencies
*
* @return void
*/
public function setUp()
{
$this->cache = new StringFrontend('TestCache', new TransientMemoryBackend(new EnvironmentConfiguration('Hash Testing', '/some/path', PHP_MAXPATHLEN)));
$this->cache->initializeObject();
$this->mockObjectManager = $this->getMockBuilder(ObjectManagerInterface::class)->getMock();
$this->hashService = new HashService();
$this->inject($this->hashService, 'cache', $this->cache);
$this->inject($this->hashService, 'objectManager', $this->mockObjectManager);
$this->hashService->injectSettings($this->mockSettings);
}
/**
* @test
*/
public function storeResolvedUriPathConvertsObjectsImplementingCacheAwareInterfaceToCacheEntryIdentifier()
{
$mockObject = $this->createMock(CacheAwareInterface::class);
$mockObject->expects($this->atLeastOnce())->method('getCacheEntryIdentifier')->will($this->returnValue('objectIdentifier'));
$routeValues = ['b' => 'route values', 'someObject' => $mockObject];
$cacheIdentifier = '264b593d59582adea4ccc52b33cc093f';
$matchingUriPath = 'uncached/matching/uri';
$this->mockResolveCache->expects($this->once())->method('set')->with($cacheIdentifier, $matchingUriPath);
$this->routerCachingService->storeResolvedUriPath($matchingUriPath, $routeValues);
}
/**
* Returns the encryption key from the persistent cache or Data/Persistent directory. If none exists, a new
* encryption key will be generated and stored in the cache.
*
* @return string The configured encryption key stored in Data/Persistent/EncryptionKey
*/
protected function getEncryptionKey()
{
if ($this->encryptionKey === null) {
$this->encryptionKey = $this->cache->get('encryptionKey');
}
if ($this->encryptionKey === false && file_exists(FLOW_PATH_DATA . 'Persistent/EncryptionKey')) {
$this->encryptionKey = file_get_contents(FLOW_PATH_DATA . 'Persistent/EncryptionKey');
}
if ($this->encryptionKey === false) {
$this->encryptionKey = bin2hex(Utility\Algorithms::generateRandomBytes(48));
$this->cache->set('encryptionKey', $this->encryptionKey);
}
return $this->encryptionKey;
}
/**
* Loads all node types into memory.
*
* @return void
*/
protected function loadNodeTypes()
{
$this->fullNodeTypeConfigurations = $this->fullConfigurationCache->get('fullNodeTypeConfigurations');
$fillFullConfigurationCache = !is_array($this->fullNodeTypeConfigurations);
$completeNodeTypeConfiguration = $this->configurationManager->getConfiguration('NodeTypes');
foreach (array_keys($completeNodeTypeConfiguration) as $nodeTypeName) {
if (!is_array($completeNodeTypeConfiguration[$nodeTypeName])) {
continue;
}
$nodeType = $this->loadNodeType($nodeTypeName, $completeNodeTypeConfiguration, isset($this->fullNodeTypeConfigurations[$nodeTypeName]) ? $this->fullNodeTypeConfigurations[$nodeTypeName] : null);
if ($fillFullConfigurationCache) {
$this->fullNodeTypeConfigurations[$nodeTypeName] = $nodeType->getFullConfiguration();
}
}
if ($fillFullConfigurationCache) {
$this->fullConfigurationCache->set('fullNodeTypeConfigurations', $this->fullNodeTypeConfigurations);
}
$this->fullNodeTypeConfigurations = null;
}
/**
* Logs a user in if a session identifier is available under the given token in the token cache.
*
* @param string $token
* @return void
*/
public function tokenLoginAction($token)
{
$newSessionId = $this->loginTokenCache->get($token);
$this->loginTokenCache->remove($token);
if ($newSessionId === false) {
$this->systemLogger->log(sprintf('Token-based login failed, non-existing or expired token %s', $token), LOG_WARNING);
$this->redirect('index');
}
$this->systemLogger->log(sprintf('Token-based login succeeded, token %s', $token), LOG_DEBUG);
$newSession = $this->sessionManager->getSession($newSessionId);
if ($newSession->canBeResumed()) {
$newSession->resume();
}
if ($newSession->isStarted()) {
$newSession->putData('lastVisitedNode', null);
} else {
$this->systemLogger->log(sprintf('Failed resuming or starting session %s which was referred to in the login token %s.', $newSessionId, $token), LOG_ERR);
}
$this->replaceSessionCookie($newSessionId);
$this->redirect('index', 'Backend\\Backend');
}
/**
* Constructs the cache
*
* @param string $identifier A identifier which describes this cache
* @param PhpCapableBackendInterface $backend Backend to be used for this cache
*/
public function __construct($identifier, PhpCapableBackendInterface $backend)
{
parent::__construct($identifier, $backend);
}
/**
* Store the changed directories and files back to the cache.
*
* @return void
*/
protected function saveDetectedDirectoriesAndFiles()
{
$this->cache->set($this->identifier . '_directoriesAndFiles', json_encode($this->directoriesAndFiles));
}
/**
* Flush all content cache entries
*
* @return void
*/
public function flush()
{
$this->cache->flush();
}
/**
* Caches the file modification times
*
* @return void
*/
public function shutdownObject()
{
if ($this->modificationTimesChanged === true) {
$this->cache->set($this->fileMonitor->getIdentifier() . '_filesAndModificationTimes', json_encode($this->filesAndModificationTimes));
}
}
/**
* Flushes 'findMatchResults' and 'resolve' caches for the given $tag
*
* @param string $tag
* @return void
*/
public function flushCachesByTag($tag)
{
$this->routeCache->flushByTag($tag);
$this->resolveCache->flushByTag($tag);
}
/**
* Set updated reflection data to caches.
*/
protected function updateReflectionData()
{
$this->log(sprintf('Found %s classes whose reflection data was not cached previously.', count($this->updatedReflectionData)), LOG_DEBUG);
foreach (array_keys($this->updatedReflectionData) as $className) {
$this->statusCache->set($this->produceCacheIdentifierFromClassName($className), '');
}
$data = [];
$propertyNames = ['classReflectionData', 'classSchemata', 'annotatedClasses', 'classesByMethodAnnotations'];
foreach ($propertyNames as $propertyName) {
$data[$propertyName] = $this->{$propertyName};
}
$this->reflectionDataCompiletimeCache->set('ReflectionData', $data);
}
/**
* @test
*/
public function getByTagCallsBackendAndReturnsIdentifiersAndValuesOfEntries()
{
$tag = 'sometag';
$identifiers = ['one', 'two'];
$entries = ['one' => 'one value', 'two' => 'two value'];
$backend = $this->prepareDefaultBackend();
$backend->expects($this->once())->method('findIdentifiersByTag')->with($this->equalTo($tag))->will($this->returnValue($identifiers));
$backend->expects($this->exactly(2))->method('get')->will($this->onConsecutiveCalls('one value', 'two value'));
$cache = new StringFrontend('StringFrontend', $backend);
$this->assertEquals($entries, $cache->getByTag($tag), 'Did not receive the expected entries');
}