/**
* Initialize cache
*
* @return void
*/
protected function initializeCache()
{
$this->cacheManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager');
try {
$this->frontend = $this->cacheManager->getCache('cartography_cache');
} catch (NoSuchCacheException $e) {
}
}
/**
* Initializes the cache for this command.
*
* @return void
*/
protected function initializeCache()
{
try {
$this->cacheInstance = $this->cacheManager->getCache('tx_solr');
} catch (NoSuchCacheException $e) {
$this->cacheInstance = $this->cacheFactory->create('tx_solr', $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['tx_solr']['frontend'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['tx_solr']['backend'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['tx_solr']['options']);
}
}
/**
*
*/
public function initializeObject()
{
try {
$this->cacheInstance = $this->cacheManager->getCache(self::CACHE_NAME);
} catch (NoSuchCacheException $e) {
$this->cacheInstance = $this->cacheFactory->create(self::CACHE_NAME, $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['typo3forum_main']['frontend'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['typo3forum_main']['backend'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['typo3forum_main']['options']);
}
}
/**
* Returns the cache object
* @return mixed
* @throws \Exception
*/
protected function getCache()
{
try {
$cache = $this->cacheManager->getCache('cicbase_cache');
} catch (\TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException $e) {
throw new \Exception('Unable to load the cicbase cache.');
}
return $cache;
}
/**
* Returns a cache instance.
*
* @param string $name Name of the cache. Must be one of the class' constants.
* @return FrontendInterface
*/
public static function getCacheInstance($name)
{
if (!self::$cacheManager) {
self::$cacheManager = Core::getObjectManager()->get(TYPO3CacheManager::class);
}
$cacheInstance = null;
switch ($name) {
case self::CACHE_MAIN:
case self::CACHE_PROCESSED:
$cacheInstance = self::$cacheManager->getCache($name);
}
return $cacheInstance;
}
/**
* Clears the page cache
*
* @param mixed $pageIdsToClear (int) single or (array) multiple pageIds to clear the cache for
* @return void
*/
public function clearPageCache($pageIdsToClear = null)
{
if ($pageIdsToClear === null) {
$this->cacheManager->flushCachesInGroup('pages');
} else {
if (!is_array($pageIdsToClear)) {
$pageIdsToClear = array((int) $pageIdsToClear);
}
foreach ($pageIdsToClear as $pageId) {
$this->cacheManager->flushCachesInGroupByTag('pages', 'pageId_' . $pageId);
}
}
}
/**
* Flush menu cache for pages that were automatically published
* between two runs of this command
*
* @return void
*/
public function clearMenuForPulishedPagesCommand()
{
$current = time();
$last = $this->registry->get('tx_autoflush', self::REGISTRY_KEY, $current);
$pages = $this->findPagesPublishedBetween($last, $current);
$pids = array();
if ($pages) {
foreach ($pages as $page) {
$pids[$page['pid']] = $page['pid'];
}
}
foreach ($pids as $pid) {
$this->cacheManager->flushCachesInGroupByTag('pages', 'menu_pid_' . $pid);
}
$this->registry->set('tx_autoflush', self::REGISTRY_KEY, $current);
}
/**
* Get schema SQL of required cache framework tables.
*
* This method needs ext_localconf and ext_tables loaded!
*
* @return string Cache framework SQL
*/
public function getCachingFrameworkRequiredDatabaseSchema()
{
// Use new to circumvent the singleton pattern of CacheManager
$cacheManager = new CacheManager();
$cacheManager->setCacheConfigurations($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
// Cache manager needs cache factory. cache factory injects itself to manager in __construct()
new CacheFactory('production', $cacheManager);
$tableDefinitions = '';
foreach ($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations'] as $cacheName => $_) {
$backend = $cacheManager->getCache($cacheName)->getBackend();
if (method_exists($backend, 'getTableDefinitions')) {
$tableDefinitions .= LF . $backend->getTableDefinitions();
}
}
return $tableDefinitions;
}
/**
* @return NULL
*/
public function writeCachedConfigurationIfMissing()
{
/** @var StringFrontend $cache */
$cache = $this->manager->getCache('fluidcontent');
$hasCache = $cache->has('pageTsConfig');
if (TRUE === $hasCache) {
return;
}
$templates = $this->getAllRootTypoScriptTemplates();
$paths = $this->getPathConfigurationsFromRootTypoScriptTemplates($templates);
$pageTsConfig = '';
$this->backupPageUidForConfigurationManager();
foreach ($paths as $pageUid => $collection) {
if (FALSE === $collection) {
continue;
}
try {
$this->overrideCurrentPageUidForConfigurationManager($pageUid);
$wizardTabs = $this->buildAllWizardTabGroups($collection);
$collectionPageTsConfig = $this->buildAllWizardTabsPageTsConfig($wizardTabs);
$pageTsConfig .= '[PIDinRootline = ' . strval($pageUid) . ']' . LF;
$pageTsConfig .= $collectionPageTsConfig . LF;
$pageTsConfig .= '[GLOBAL]' . LF;
$this->message('Built content setup for page ' . $pageUid, GeneralUtility::SYSLOG_SEVERITY_INFO, 'Fluidcontent');
} catch (\Exception $error) {
$this->debug($error);
}
}
$this->restorePageUidForConfigurationManager();
$cache->set('pageTsConfig', $pageTsConfig, array(), 806400);
return NULL;
}
/**
* Initializes the Reflection Service
*
* @return void
* @see initialize()
*/
protected function initializeReflection()
{
$this->reflectionService = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Reflection\\ReflectionService');
$this->reflectionService->setDataCache($this->cacheManager->getCache('extbase_reflection'));
if (!$this->reflectionService->isInitialized()) {
$this->reflectionService->initialize();
}
}
/**
* @param string $classFile
* @param string $className
* @param bool $triggerRequire
*/
protected function writeCacheEntryForClass($className, $classFile, $triggerRequire = FALSE)
{
$classesCache = $this->cacheManager->getCache('cache_classes');
$cacheEntryIdentifier = strtolower(str_replace('\\', '_', $className));
$classLoadingInformation = array($classFile, strtolower($className));
if (!$classesCache->has($cacheEntryIdentifier)) {
$classesCache->set($cacheEntryIdentifier, implode("ÿ", $classLoadingInformation));
}
}
/**
* @return void
*/
public function writeCachedConfigurationIfMissing()
{
/** @var StringFrontend $cache */
$cache = $this->manager->getCache('fluidcontent');
$hasCache = $cache->has('pageTsConfig');
if (FALSE === $hasCache) {
$cache->set('pageTsConfig', $this->getPageTsConfig(), array(), 86400);
}
}
/**
* Get the cache to retrieve labels.
*
* @return \TYPO3\CMS\Core\Cache\Cache
*/
private function getCache()
{
if ($this->cache === null) {
try {
$this->cache = $this->cacheManager->getCache('tev_label_label_cache');
} catch (NoSuchCacheException $e) {
$this->cache = $this->cacheFactory->create('tev_label_label_cache', $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['tev_label_label_cache']['frontend'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['tev_label_label_cache']['backend'], $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['tev_label_label_cache']['options']);
}
}
return $this->cache;
}
/**
* Initializes this object. This is called by the storage after the driver
* has been attached.
*
* @return void
*/
public function initialize()
{
$this->objectManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager');
$this->cacheManager = $this->objectManager->get('TYPO3\\CMS\\Core\\Cache\\CacheManager');
$this->cache = $this->cacheManager->getCache('fal_dropbox');
if (!empty($this->configuration['accessToken'])) {
$this->dropboxClient = $this->objectManager->get('SFroemken\\FalDropbox\\Dropbox\\Client', $this->configuration['accessToken'], 'TYPO3 CMS');
} else {
$this->dropboxClient = NULL;
}
}
/**
* @test
*/
public function clearsCachesOfDuplicateRegisteredPageIdsOnlyOnce()
{
$this->cacheManagerMock->expects($this->at(0))->method('flushCachesInGroupByTag')->with('pages', 'pageId_2');
$this->cacheManagerMock->expects($this->at(1))->method('flushCachesInGroupByTag')->with('pages', 'pageId_15');
$this->cacheManagerMock->expects($this->at(2))->method('flushCachesInGroupByTag')->with('pages', 'pageId_8');
$this->cacheManagerMock->expects($this->exactly(3))->method('flushCachesInGroupByTag');
$this->cacheService->getPageIdStack()->push(8);
$this->cacheService->getPageIdStack()->push(15);
$this->cacheService->getPageIdStack()->push(15);
$this->cacheService->getPageIdStack()->push(2);
$this->cacheService->getPageIdStack()->push(2);
$this->cacheService->clearCachesOfRegisteredPageIds();
}
/**
* @return void
*/
protected function initializeExtbaseFramework()
{
// initialize cache manager
$this->cacheManager = $GLOBALS['typo3CacheManager'];
// inject content object into the configuration manager
$this->configurationManager = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Configuration\\ConfigurationManagerInterface');
$contentObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer');
$this->configurationManager->setContentObject($contentObject);
$this->typoScriptService->makeTypoScriptBackup();
// load extbase typoscript
TypoScriptService::loadTypoScriptFromFile('EXT:extbase/ext_typoscript_setup.txt');
TypoScriptService::loadTypoScriptFromFile('EXT:ap_ldap_auth/ext_typoscript_setup.txt');
$this->configurationManager->setConfiguration($GLOBALS['TSFE']->tmpl->setup);
$this->configureObjectManager();
// initialize reflection
$this->reflectionService = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Reflection\\ReflectionService');
$this->reflectionService->setDataCache($this->cacheManager->getCache('extbase_reflection'));
if (!$this->reflectionService->isInitialized()) {
$this->reflectionService->initialize();
}
// initialize persistence
$this->persistenceManager = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Persistence\\Generic\\PersistenceManager');
}
/**
* @return void
*/
public function writeCachedConfigurationIfMissing()
{
/** @var StringFrontend $cache */
$cache = $this->manager->getCache('fluidcontent');
$hasCache = $cache->has('pageTsConfig');
if (FALSE === $hasCache) {
$pageTsConfig = '';
$templates = $this->getAllRootTypoScriptTemplates();
foreach ($templates as $template) {
$pageUid = (int) $template['pid'];
$pageTsConfig .= $this->renderPageTypoScriptForPageUid($pageUid);
}
$cache->set('pageTsConfig', $pageTsConfig, array(), 86400);
}
}
/**
* Factory method which creates the specified cache along with the specified kind of backend.
* After creating the cache, it will be registered at the cache manager.
*
* @param string $cacheIdentifier The name / identifier of the cache to create
* @param string $cacheObjectName Object name of the cache frontend
* @param string $backendObjectName Object name of the cache backend
* @param array $backendOptions (optional) Array of backend options
* @return \TYPO3\CMS\Core\Cache\Frontend\FrontendInterface The created cache frontend
* @throws \TYPO3\CMS\Core\Cache\Exception\InvalidBackendException if the cache backend is not valid
* @throws \TYPO3\CMS\Core\Cache\Exception\InvalidCacheException if the cache frontend is not valid
* @api
*/
public function create($cacheIdentifier, $cacheObjectName, $backendObjectName, array $backendOptions = array())
{
// New operator used on purpose: This class is required early during
// bootstrap before makeInstance() is propely set up
$backendObjectName = '\\' . ltrim($backendObjectName, '\\');
$backend = new $backendObjectName($this->context, $backendOptions);
if (!$backend instanceof \TYPO3\CMS\Core\Cache\Backend\BackendInterface) {
throw new \TYPO3\CMS\Core\Cache\Exception\InvalidBackendException('"' . $backendObjectName . '" is not a valid cache backend object.', 1216304301);
}
if (is_callable(array($backend, 'initializeObject'))) {
$backend->initializeObject();
}
// New used on purpose, see comment above
$cache = new $cacheObjectName($cacheIdentifier, $backend);
if (!$cache instanceof \TYPO3\CMS\Core\Cache\Frontend\FrontendInterface) {
throw new \TYPO3\CMS\Core\Cache\Exception\InvalidCacheException('"' . $cacheObjectName . '" is not a valid cache frontend object.', 1216304300);
}
if (is_callable(array($cache, 'initializeObject'))) {
$cache->initializeObject();
}
$this->cacheManager->registerCache($cache);
return $cache;
}
/**
* Wrapper function for unloading extensions
*
* @param string $extensionKey
* @return void
*/
protected function unloadExtension($extensionKey)
{
$this->packageManager->deactivatePackage($extensionKey);
$this->cacheManager->flushCachesInGroup('system');
}
/**
* @param ConsoleBootstrap $bootstrap
*/
public static function initializeCachingFramework(ConsoleBootstrap $bootstrap)
{
// Cache framework initialisation for TYPO3 CMS <= 7.3
if (class_exists('TYPO3\\CMS\\Core\\Cache\\Cache')) {
$bootstrap->setEarlyInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager', \TYPO3\CMS\Core\Cache\Cache::initializeCachingFramework());
// @deprecated since 6.2 will be removed in two versions
if (class_exists('TYPO3\\CMS\\Core\\Compatibility\\GlobalObjectDeprecationDecorator')) {
$GLOBALS['typo3CacheManager'] = new \TYPO3\CMS\Core\Compatibility\GlobalObjectDeprecationDecorator('TYPO3\\CMS\\Core\\Cache\\CacheManager');
$GLOBALS['typo3CacheFactory'] = new \TYPO3\CMS\Core\Compatibility\GlobalObjectDeprecationDecorator('TYPO3\\CMS\\Core\\Cache\\CacheFactory');
}
} else {
$cacheManager = new \TYPO3\CMS\Core\Cache\CacheManager();
$cacheManager->setCacheConfigurations($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
\TYPO3\CMS\Core\Utility\GeneralUtility::setSingletonInstance(\TYPO3\CMS\Core\Cache\CacheManager::class, $cacheManager);
$cacheFactory = new \TYPO3\CMS\Core\Cache\CacheFactory('production', $cacheManager);
\TYPO3\CMS\Core\Utility\GeneralUtility::setSingletonInstance(\TYPO3\CMS\Core\Cache\CacheFactory::class, $cacheFactory);
$bootstrap->setEarlyInstance(\TYPO3\CMS\Core\Cache\CacheManager::class, $cacheManager);
}
}
/**
* Sets up this test case
*
* @return void
*/
protected function setUp()
{
$this->singletonInstances = GeneralUtility::getSingletonInstances();
$this->view = $this->getAccessibleMock(\TYPO3\CMS\Fluid\View\StandaloneView::class, array('testFileExistence', 'buildParserConfiguration', 'getOrParseAndStoreTemplate'), array(), '', false);
$this->mockConfigurationManager = $this->getMock(ConfigurationManagerInterface::class);
$this->mockObjectManager = $this->getMock(\TYPO3\CMS\Extbase\Object\ObjectManager::class);
$this->mockObjectManager->expects($this->any())->method('get')->will($this->returnCallback(array($this, 'objectManagerCallback')));
$this->mockRequest = $this->getMock(Request::class);
$this->mockUriBuilder = $this->getMock(UriBuilder::class);
$this->mockContentObject = $this->getMock(\TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer::class);
$this->mockControllerContext = $this->getMock(ControllerContext::class);
$this->mockControllerContext->expects($this->any())->method('getRequest')->will($this->returnValue($this->mockRequest));
$this->mockTemplatePaths = $this->getMock(TemplatePaths::class);
$this->mockViewHelperVariableContainer = $this->getMock(ViewHelperVariableContainer::class);
$this->mockRenderingContext = $this->getMock(\TYPO3\CMS\Fluid\Tests\Unit\Core\Rendering\RenderingContextFixture::class);
$this->mockRenderingContext->expects($this->any())->method('getControllerContext')->will($this->returnValue($this->mockControllerContext));
$this->mockRenderingContext->expects($this->any())->method('getViewHelperVariableContainer')->will($this->returnValue($this->mockViewHelperVariableContainer));
$this->mockRenderingContext->expects($this->any())->method('getVariableProvider')->willReturn($this->mockVariableProvider);
$this->mockRenderingContext->expects($this->any())->method('getTemplatePaths')->willReturn($this->mockTemplatePaths);
$this->view->_set('objectManager', $this->mockObjectManager);
$this->view->_set('baseRenderingContext', $this->mockRenderingContext);
$this->view->_set('controllerContext', $this->mockControllerContext);
$this->view->expects($this->any())->method('getOrParseAndStoreTemplate')->willReturn($this->mockParsedTemplate);
GeneralUtility::setSingletonInstance(\TYPO3\CMS\Extbase\Object\ObjectManager::class, $this->mockObjectManager);
GeneralUtility::addInstance(\TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer::class, $this->mockContentObject);
$this->mockCacheManager = $this->getMock(\TYPO3\CMS\Core\Cache\CacheManager::class, array(), array(), '', false);
$mockCache = $this->getMock(\TYPO3Fluid\Fluid\Core\Cache\FluidCacheInterface::class, array(), array(), '', false);
$this->mockCacheManager->expects($this->any())->method('getCache')->will($this->returnValue($mockCache));
GeneralUtility::setSingletonInstance(\TYPO3\CMS\Core\Cache\CacheManager::class, $this->mockCacheManager);
}
/**
* Lifecycle method
*
* @return void
*/
public function initializeObject()
{
$this->tableColumnCache = $this->cacheManager->getCache('extbase_typo3dbbackend_tablecolumns');
$this->queryCache = $this->cacheManager->getCache('extbase_typo3dbbackend_queries');
}
/**
* Flush cache
*
* @return void
*/
public function flush()
{
$this->cacheManager->getCache($this->cacheName)->flush();
}
/**
* @test
*/
public function getClassTagRendersTagWhichCanBeUsedToTagACacheEntryWithACertainClass()
{
$identifier = 'someCacheIdentifier';
$backend = $this->getMock('TYPO3\\CMS\\Core\\Cache\\Backend\\AbstractBackend', array('get', 'set', 'has', 'remove', 'findIdentifiersByTag', 'flush', 'flushByTag', 'collectGarbage'), array(), '', FALSE);
$cache = $this->getMock('TYPO3\\CMS\\Core\\Cache\\Frontend\\StringFrontend', array('__construct', 'get', 'set', 'has', 'remove', 'getByTag'), array($identifier, $backend));
$this->assertEquals('%CLASS%F3_Foo_Bar_Baz', \TYPO3\CMS\Core\Cache\CacheManager::getClassTag('F3\\Foo\\Bar\\Baz'));
}
/**
* A slot method to inject the required caching framework database tables to the
* tables definitions string
*
* @param array $sqlString
* @param string $extensionKey
* @return array
*/
public function addCachingFrameworkRequiredDatabaseSchemaToTablesDefinition(array $sqlString, $extensionKey)
{
self::$cacheManager->setCacheConfigurations($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
$sqlString[] = static::getDatabaseTableDefinitions();
return array('sqlString' => $sqlString, 'extensionKey' => $extensionKey);
}
/**
* Construct
*
* @param CacheManager $cacheManager Application CacheManager
*
* @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException The application
* caching framework will throw this exception if the specified cache isn't
* properly configured.
*/
public function __construct(CacheManager $cacheManager)
{
$this->cache = $cacheManager->getCache('cache_hash');
}
/**
* @param CacheManager $cacheManager
*/
public function __construct(CacheManager $cacheManager)
{
$this->cache = $cacheManager->getCache('codesnippet_brushes');
}
/**
* @param \TYPO3\CMS\Core\Cache\CacheManager $cacheManager
* @return void
*/
public function injectCacheManager(\TYPO3\CMS\Core\Cache\CacheManager $cacheManager)
{
$this->tokenCache = $cacheManager->getCache('hairu_token');
}
/**
* Initializes the cache and determines caching method.
*
* @author Martin Helmich <*****@*****.**>
* @version 2008-10-11
* @param string $mode The caching mode. This may either be 'auto',
* 'apc','database','file' or 'none' (see above).
* @param array $configuration
* @throws Exception
*/
function init($mode = 'auto', $configuration = array())
{
/* If mode is set to 'auto' or 'apc', first try to set mode
* to APC (if enabled) or otherwise to database. */
if ($mode == 'auto' || $mode == 'apc') {
if ($this->getAPCEnabled()) {
$useMode = 'apc';
} else {
$useMode = 'database';
}
/* If mode is set to 'file',... */
} elseif ($mode == 'file') {
$useMode = 'file';
} elseif ($mode == 'none') {
$useMode = 'none';
} else {
$useMode = 'database';
}
/* Compose class name and instantiate */
if (isset($GLOBALS['typo3CacheManager'])) {
$this->useTYPO3Cache = TRUE;
if ($useMode == 'database') {
$this->cacheObj =& $this->typo3CacheManager->getCache('cache_hash');
} else {
if ($this->typo3CacheManager->hasCache('mm_forum')) {
$this->cacheObj =& $this->typo3CacheManager->getCache('mm_forum');
} else {
switch ($useMode) {
case 'database':
$className = 't3lib_cache_backend_DbBackend';
break;
case 'apc':
$className = 't3lib_cache_backend_ApcBackend';
break;
case 'file':
$className = 't3lib_cache_backend_FileBackend';
break;
case 'none':
$className = 't3lib_cache_backend_NullBackend';
break;
case 'globals':
$className = 't3lib_cache_backend_GlobalsBackend';
break;
default:
throw new Exception("Unknown caching mode: {$useMode}", 1296594227);
}
if (!class_exists($className) && file_exists(PATH_t3lib . 'cache/backend/class.' . strtolower($className) . '.php')) {
include_once PATH_t3lib . 'cache/backend/class.' . strtolower($className) . '.php';
} elseif (!class_exists($className)) {
$this->cacheObj =& $this->typo3CacheManager->getCache('cache_hash');
}
if (class_exists($className)) {
$cacheBackend = GeneralUtility::makeInstance($className, $configuration);
$cacheObject = GeneralUtility::makeInstance('t3lib_cache_frontend_VariableFrontend', 'mm_forum', $cacheBackend);
$this->typo3CacheManager->registerCache($cacheObject);
$this->cacheObj =& $this->typo3CacheManager->getCache('mm_forum');
} else {
throw new Exception("Cache backend does not exist: {$className}", 1296594228);
}
}
}
} else {
$className = 'tx_mmforum_cache_' . $useMode;
$this->cacheObj =& GeneralUtility::makeInstance($className);
}
}
/**
* @param CacheManager $cacheManager
*
* @throws \TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException
*/
public function injectCacheManager(CacheManager $cacheManager)
{
$this->cache = $cacheManager->getCache('codesnippet_brushes');
}