/**
* @param string $name
* @param mixed $value
* @param string $cacheFileName
* @return mixed|null
*/
public static function dailyValue( $name, $value = null, $cacheFileName = null )
{
if ( $value === null && isset($memoryCache[$name]) && $cacheFileName === null )
{
return self::$memoryCache[$name];
}
else
{
if (is_null($cacheFileName))
{
$cacheFileName = self::DAILY_CACHE_FILE . '_' . ClusterTool::clusterIdentifier();
}
$cache = new eZPHPCreator(
eZSys::cacheDirectory(),
$cacheFileName . '.php',
'',
array()
);
$expiryTime = time() - 24 * 3600;
// reading
if ($cache->canRestore($expiryTime))
{
$values = $cache->restore(array('cacheTable' => 'cacheTable'));
if (is_null($value))
{
if (isset($values['cacheTable'][$name]))
{
return $values['cacheTable'][$name];
}
else
{
return null;
}
}
}
else
{
$values = array('cacheTable' => array());
}
$values['cacheTable'][$name] = $value;
if ( $cacheFileName == self::DAILY_CACHE_FILE . '_' . ClusterTool::clusterIdentifier() )
self::$memoryCache = $values['cacheTable'];
// writing
$cache->addVariable('cacheTable', $values['cacheTable']);
$cache->store(true);
$cache->close();
}
return null;
}
/**
* Test scenario for issue #014897: Object/class name pattern and cache issues [patch]
*
* @result $phpCache->canRestore() returns true
* @expected $phpCache->canRestore() should return false
*
* @link http://issues.ez.no/14897
*/
public function testCanRestore()
{
$db = eZDB::instance();
$dbName = md5($db->DB);
$cacheDir = eZSys::cacheDirectory();
$phpCache = new eZPHPCreator($cacheDir, 'classidentifiers_' . $dbName . '.php', '', array('clustering' => 'classidentifiers'));
$handler = eZExpiryHandler::instance();
$expiryTime = 0;
if ($handler->hasTimestamp('class-identifier-cache')) {
$expiryTime = $handler->timestamp('class-identifier-cache');
}
$this->assertFalse($phpCache->canRestore($expiryTime));
}
/**
* @param string $name
* @param mixed $value
* @return array
*/
public static function dailyValue( $name, $value = null)
{
if ( $value === null && isset($memoryCache[$name]) )
{
return self::$memoryCache[$name];
}
else
{
$cache = new eZPHPCreator(
eZSys::cacheDirectory(),
self::GLOBAL_CACHE_FILE . '.php',
'',
array() // removed clustering
);
$expiryTime = time() - 24 * 3600;
// reading
if ($cache->canRestore($expiryTime))
{
$values = $cache->restore(array('cacheTable' => 'cacheTable'));
self::$memoryCache = $values['cacheTable'];
if (is_null($value))
{
if (isset($values['cacheTable'][$name]))
{
return $values['cacheTable'][$name];
}
else
{
return null;
}
}
}
else
{
$values = array('cacheTable' => array());
}
if ( !is_null($value) )
{
$values['cacheTable'][$name] = $value;
$cache->addVariable('cacheTable', $values['cacheTable']);
$cache->store(true);
$cache->close();
}
}
return null;
}
static function hasCompiledTemplate($key, $timestamp, &$resourceData)
{
if (!eZTemplateCompiler::isCompilationEnabled()) {
return false;
}
if (eZTemplateCompiler::alwaysGenerate()) {
return false;
}
$cacheFileName = eZTemplateCompiler::compilationFilename($key, $resourceData);
$php = new eZPHPCreator(eZTemplateCompiler::compilationDirectory(), $cacheFileName, eZTemplateCompiler::TemplatePrefix());
$canRestore = $php->canRestore($timestamp);
$uri = false;
if ($canRestore) {
eZDebugSetting::writeDebug('eztemplate-compile', "Cache hit for uri '{$uri}' with key '{$key}'", 'eZTemplateCompiler::hasCompiledTemplate');
} else {
eZDebugSetting::writeDebug('eztemplate-compile', "Cache miss for uri '{$uri}' with key '{$key}'", 'eZTemplateCompiler::hasCompiledTemplate');
}
return $canRestore;
}
/**
* Returns the class identifier hash for the current database.
* If it is outdated or non-existent, the method updates/generates the file
*
* @static
* @since Version 4.1
* @access protected
* @return array Returns hash of classidentifier => classid
*/
protected static function classIdentifiersHash()
{
if (self::$identifierHash === null) {
$db = eZDB::instance();
$dbName = md5($db->DB);
$cacheDir = eZSys::cacheDirectory();
$phpCache = new eZPHPCreator($cacheDir, 'classidentifiers_' . $dbName . '.php', '', array('clustering' => 'classidentifiers'));
eZExpiryHandler::registerShutdownFunction();
$handler = eZExpiryHandler::instance();
$expiryTime = 0;
if ($handler->hasTimestamp('class-identifier-cache')) {
$expiryTime = $handler->timestamp('class-identifier-cache');
}
if ($phpCache->canRestore($expiryTime)) {
$var = $phpCache->restore(array('identifierHash' => 'identifier_hash'));
self::$identifierHash = $var['identifierHash'];
} else {
// Fetch identifier/id pair from db
$query = "SELECT id, identifier FROM ezcontentclass where version=0";
$identifierArray = $db->arrayQuery($query);
self::$identifierHash = array();
foreach ($identifierArray as $identifierRow) {
self::$identifierHash[$identifierRow['identifier']] = $identifierRow['id'];
}
// Store identifier list to cache file
$phpCache->addVariable('identifier_hash', self::$identifierHash);
$phpCache->store();
}
}
return self::$identifierHash;
}
/**
* Return an array with activated extensions.
*
* @note Default extensions are those who are loaded before a siteaccess are determined while access extensions
* are loaded after siteaccess is set.
*
* @param false|string $extensionType Decides which extension to include in the list, the follow values are possible:
* - false - Means add both default and access extensions
* - 'default' - Add only default extensions
* - 'access' - Add only access extensions
* @param eZINI|null $siteINI Optional parameter to be able to only do change on specific instance of site.ini
* @return array
*/
public static function activeExtensions( $extensionType = false, eZINI $siteINI = null )
{
if ( $siteINI === null )
{
$siteINI = eZINI::instance();
}
$activeExtensions = array();
if ( !$extensionType || $extensionType === 'default' )
{
$activeExtensions = $siteINI->variable( 'ExtensionSettings', 'ActiveExtensions' );
}
if ( !$extensionType || $extensionType === 'access' )
{
$activeExtensions = array_merge( $activeExtensions,
$siteINI->variable( 'ExtensionSettings', 'ActiveAccessExtensions' ) );
}
if ( isset( $GLOBALS['eZActiveExtensions'] ) )
{
$activeExtensions = array_merge( $activeExtensions,
$GLOBALS['eZActiveExtensions'] );
}
// return empty array as is to avoid further unneeded overhead
if ( !isset( $activeExtensions[0] ) )
{
return $activeExtensions;
}
// return array as is if ordering is disabled to avoid cache overhead
$activeExtensions = array_unique( $activeExtensions );
if ( $siteINI->variable( 'ExtensionSettings', 'ExtensionOrdering' ) !== 'enabled' )
{
// @todo Introduce a debug setting or re use existing dev mods to check that all extensions exists
return $activeExtensions;
}
$cacheIdentifier = md5( serialize( $activeExtensions ) );
if ( isset ( self::$activeExtensionsCache[$cacheIdentifier] ) )
{
return self::$activeExtensionsCache[$cacheIdentifier];
}
// cache has to be stored by siteaccess + $extensionType
$extensionDirectory = self::baseDirectory();
$expiryHandler = eZExpiryHandler::instance();
$phpCache = new eZPHPCreator( self::CACHE_DIR, "active_extensions_{$cacheIdentifier}.php" );
$expiryTime = $expiryHandler->hasTimestamp( 'active-extensions-cache' ) ? $expiryHandler->timestamp( 'active-extensions-cache' ) : 0;
if ( !$phpCache->canRestore( $expiryTime ) )
{
self::$activeExtensionsCache[$cacheIdentifier] = self::extensionOrdering( $activeExtensions );
// Check that all extensions defined actually exists before storing cache
foreach ( self::$activeExtensionsCache[$cacheIdentifier] as $activeExtension )
{
if ( !file_exists( $extensionDirectory . '/' . $activeExtension ) )
{
eZDebug::writeError( "Extension '$activeExtension' does not exist, looked for directory '" . $extensionDirectory . '/' . $activeExtension . "'", __METHOD__ );
}
}
$phpCache->addVariable( 'activeExtensions', self::$activeExtensionsCache[$cacheIdentifier] );
$phpCache->store();
}
else
{
$data = $phpCache->restore( array( 'activeExtensions' => 'activeExtensions' ) );
self::$activeExtensionsCache[$cacheIdentifier] = $data['activeExtensions'];
}
return self::$activeExtensionsCache[$cacheIdentifier];
}
static function canRestoreCache($key, $timestamp, $templateFilepath)
{
if (!eZTemplateTreeCache::isCacheEnabled()) {
return false;
}
$templateCache =& eZTemplateTreeCache::cacheTable();
$key = eZTemplateTreeCache::internalKey($key);
if (isset($templateCache[$key])) {
return false;
}
$cacheFileName = eZTemplateTreeCache::treeCacheFilename($key, $templateFilepath);
$php = new eZPHPCreator(eZTemplateTreeCache::cacheDirectory(), $cacheFileName);
return $php->canRestore($timestamp);
}
static function canRestoreCache($key, $timestamp)
{
$translationCache = eZTranslationCache::cacheTable();
if (isset($translationCache[$key])) {
return false;
}
// $internalCharset = eZTextCodec::internalCharset();
// $cacheFileKey = "$key-$internalCharset";
$cacheFileKey = $key;
$cacheFileName = md5($cacheFileKey) . '.php';
$php = new eZPHPCreator(eZTranslationCache::cacheDirectory(), $cacheFileName);
return $php->canRestore($timestamp);
}
/**
* Returns an array of limitations useable by the policy system
*
* @return array
*/
public static function limitations()
{
static $limitations;
if ($limitations === null) {
$db = eZDB::instance();
$dbName = md5($db->DB);
$cacheDir = eZSys::cacheDirectory();
$phpCache = new eZPHPCreator($cacheDir, 'statelimitations_' . $dbName . '.php', '', array('clustering' => 'statelimitations'));
$handler = eZExpiryHandler::instance();
$storedTimeStamp = $handler->hasTimestamp('state-limitations') ? $handler->timestamp('state-limitations') : false;
$expiryTime = $storedTimeStamp !== false ? $storedTimeStamp : 0;
if ($phpCache->canRestore($expiryTime)) {
$var = $phpCache->restore(array('state_limitations' => 'state_limitations'));
$limitations = $var['state_limitations'];
} else {
$limitations = array();
$groups = self::fetchByConditions(array("identifier NOT LIKE 'ez%'"), false, false);
foreach ($groups as $group) {
$name = 'StateGroup_' . $group->attribute('identifier');
$limitations[$name] = array('name' => $name, 'values' => array(), 'class' => __CLASS__, 'function' => 'limitationValues', 'parameter' => array($group->attribute('id')));
}
$phpCache->addVariable('state_limitations', $limitations);
$phpCache->store();
}
if ($storedTimeStamp === false) {
$handler->setTimestamp('state-limitations', time());
}
}
return $limitations;
}
/**
* Returns the class attribute identifier hash for the current database.
* If it is outdated or non-existent, the method updates/generates the file
*
* @static
* @since Version 4.1
* @access protected
* @return array Returns hash of classattributeidentifier => classattributeid
*/
protected static function classAttributeIdentifiersHash()
{
if (self::$identifierHash === null) {
$db = eZDB::instance();
$dbName = md5($db->DB);
$cacheDir = eZSys::cacheDirectory();
$phpCache = new eZPHPCreator($cacheDir, 'classattributeidentifiers_' . $dbName . '.php', '', array('clustering' => 'classattridentifiers'));
$handler = eZExpiryHandler::instance();
$expiryTime = 0;
if ($handler->hasTimestamp('class-identifier-cache')) {
$expiryTime = $handler->timestamp('class-identifier-cache');
}
if ($phpCache->canRestore($expiryTime)) {
$var = $phpCache->restore(array('identifierHash' => 'identifier_hash'));
self::$identifierHash = $var['identifierHash'];
} else {
// Fetch identifier/id pair from db
$query = "SELECT ezcontentclass_attribute.id as attribute_id, ezcontentclass_attribute.identifier as attribute_identifier, ezcontentclass.identifier as class_identifier\n FROM ezcontentclass_attribute, ezcontentclass\n WHERE ezcontentclass.id=ezcontentclass_attribute.contentclass_id";
$identifierArray = $db->arrayQuery($query);
self::$identifierHash = array();
foreach ($identifierArray as $identifierRow) {
$combinedIdentifier = $identifierRow['class_identifier'] . '/' . $identifierRow['attribute_identifier'];
self::$identifierHash[$combinedIdentifier] = (int) $identifierRow['attribute_id'];
}
// Store identifier list to cache file
$phpCache->addVariable('identifier_hash', self::$identifierHash);
$phpCache->store();
}
}
return self::$identifierHash;
}
