protected function setup()
{
if (!self::$stackInitialized) {
if (ezcBaseFeatures::hasExtensionSupport('apc')) {
$memoryStorage = new ezcCacheStorageApcPlain();
} else {
if (ezcBaseFeatures::hasExtensionSupport('memcache')) {
$memoryStorage = new ezcCacheStorageMemcachePlain('foo');
} else {
$this->markTestSkipped('APC or Memcached needed to run this test.');
}
}
// Start cleanly
$memoryStorage->reset();
$tmpDir = $this->createTempDir(__CLASS__);
$tmpDirEvalArray = "{$tmpDir}/plain";
$tmpDirArray = "{$tmpDir}/array";
mkdir($tmpDirEvalArray);
mkdir($tmpDirArray);
$fileStorageEvalArray = new ezcCacheStorageFileEvalArray($tmpDirEvalArray);
$fileStorageArray = new ezcCacheStorageFileArray($tmpDirArray);
ezcCacheStackTestConfigurator::reset();
ezcCacheStackTestConfigurator::$storages = array(new ezcCacheStackStorageConfiguration('eval_array_storage', $fileStorageEvalArray, 10, 0.8), new ezcCacheStackStorageConfiguration('array_storage', $fileStorageArray, 8, 0.5), new ezcCacheStackStorageConfiguration('memory_storage', $memoryStorage, 5, 0.5));
ezcCacheStackTestConfigurator::$metaStorage = $fileStorageArray;
ezcCacheManager::createCache(__CLASS__, null, 'ezcCacheStack', new ezcCacheStackOptions(array('configurator' => 'ezcCacheStackTestConfigurator', 'replacementStrategy' => 'ezcCacheStackLfuReplacementStrategy')));
self::$stackInitialized = true;
}
$this->testDataArray = array(array('id_1', 'id_1_content', array('lang' => 'en', 'area' => 'news')), array('id_2', 'id_2_content', array('lang' => 'en', 'area' => 'news')), array('id_3', 'id_3_content', array('lang' => 'de', 'area' => 'news')), array('id_4', 'id_4_content', array('lang' => 'no', 'area' => 'news')), array('id_5', 'id_5_content', array('lang' => 'de', 'area' => 'news')));
}
/**
* Extract REST routes from APC cache.
* Cache is generated if needed
* @return array The route objects
*/
protected function getCachedRoutes()
{
$ttl = (int)eZINI::instance( 'rest.ini' )->variable( 'CacheSettings', 'RouteApcCacheTTL' );
if( self::$isRouteCacheCreated === false )
{
$options = array( 'ttl' => $ttl );
ezcCacheManager::createCache( self::ROUTE_CACHE_ID, self::ROUTE_CACHE_PATH, 'ezpRestCacheStorageApcCluster', $options );
self::$isRouteCacheCreated = true;
}
$cache = ezcCacheManager::getCache( self::ROUTE_CACHE_ID );
$cacheKey = self::ROUTE_CACHE_KEY . '_' . ezpRestPrefixFilterInterface::getApiProviderName();
if( ( $prefixedRoutes = $cache->restore( $cacheKey ) ) === false )
{
try
{
$prefixedRoutes = $this->doCreateRoutes();
$cache->store( $cacheKey, $prefixedRoutes );
}
catch( Exception $e )
{
// Sometimes APC can miss a write. No big deal, just log it.
// Cache will be regenerated next time
ezpRestDebug::getInstance()->log( $e->getMessage(), ezcLog::ERROR );
}
}
return $prefixedRoutes;
}
public static function configureObject($id)
{
$options = array('ttl' => 1800);
switch ($id) {
case 'scrapers':
ezcCacheManager::createCache('scrapers', '../cache/scrapers', 'ezcCacheStorageFilePlain', $options);
break;
}
}
public static function configureObject($id)
{
$options = array('ttl' => 300);
switch ($id) {
case 'scrapers':
ezcCacheManager::createCache('scrapers', ROOT . DIRECTORY_SEPARATOR . ezcConfigurationManager::getInstance()->getSetting('movies', 'ScraperSettings', 'TempPath'), 'ezcCacheStorageFilePlain', $options);
break;
}
}
public static function configureObject($id)
{
$options = array('ttl' => 30);
switch ($id) {
case 'simple':
ezcCacheManager::createCache('simple', '/tmp/cache/plain', 'ezcCacheStorageFilePlain', $options);
break;
}
}
static function configureObject($identifier)
{
if ($identifier !== false) {
switch ($identifier) {
case 'simple':
ezcCacheManager::createCache($identifier, self::$tmpDir, 'ezcCacheStorageFilePlain');
break;
}
}
}
}
$layergroupHighlight = null;
if ($table == 'tmp') {
$enableCache = false;
$layergroupHighlight = 'g_tmp';
$idValue = session_id();
} else {
$enableCache = true;
$layergroupHighlight = "g_{$table}";
}
$fileId = $idValue . '_' . $fileDimensions;
// set cache attributes
$cacheAttributes = array('layer' => $table, 'lang' => $languages[$lang], 'id' => $idValue);
$cadastreIntersection = false;
$bufferExtent = false;
ezcCacheManager::createCache('mappreview', R3_CACHE_DIR . 'mappreview/', 'ezcCacheStorageFilePlain', array('ttl' => 5 * 24 * 60 * 60));
$cache = ezcCacheManager::getCache('mappreview');
if (!$enableCache || ($imageContent = $cache->restore($fileId, $cacheAttributes)) === false) {
list($size, $split) = explode('-', $fileDimensions);
list($x, $y) = explode('x', $size);
$size = array((int) $x, (int) $y);
list($unitDimensions, $format) = explode('.', $split);
$unitDimensions = explode('x', $unitDimensions);
try {
switch ($table) {
case 'foto':
$tableName = 'document_data';
break;
default:
$tableName = $table;
break;
/**
* @group restApplicationCache
* @group restClusterCache
* @group restCache
*/
public function testManageCache()
{
$cacheOptions = array('ttl' => 2);
$cacheID = 'test_id';
$cacheKey = 'myUniqueCacheKey';
$cacheLocation = 'myLocation';
$data = array('foo' => 'bar', 'baz' => 123, 'boolean' => true);
ezcCacheManager::createCache($cacheID, $cacheLocation, 'ezpRestCacheStorageClusterObject', $cacheOptions);
$cache = ezcCacheManager::getCache($cacheID);
$cacheContent = $cache->restore($cacheKey);
// Should be false as we didn't write anything yet
self::assertFalse($cacheContent, 'Cache should be empty before generation');
// Remaining lifetime should be 0 as cache does not exist yet
self::assertSame(0, $cache->getRemainingLifetime($cacheKey));
// Store the cache
$cache->store($cacheID, $data);
$cacheContent = $cache->restore($cacheKey);
self::assertSame($data, $cacheContent, 'Invalid cache retrieval !');
// Now check if it is present in the cluster
$cacheFullLocation = eZSys::cacheDirectory() . '/rest/' . $cacheLocation;
$cacheFile = $cacheKey . '-.cache';
self::assertTrue(eZClusterFileHandler::instance()->fileExists($cacheFullLocation . '/' . $cacheFile), 'REST cache file has not been written in the cluster');
self::assertSame(1, $cache->countDataItems($cacheKey));
self::assertGreaterThan(0, $cache->getRemainingLifetime($cacheKey), 'Invalid remaining lifetime for REST cache');
$cache->delete($cacheKey);
// Test file deletion
self::assertFalse(eZClusterFileHandler::instance()->fileExists($cacheFullLocation . '/' . $cacheFile), 'REST cache file has not been deleted from the cluster');
}
<?php
require_once 'tutorial_autoload.php';
class myCustomConfigurator implements ezcCacheStackConfigurator
{
public static function configure(ezcCacheStack $stack)
{
// ... create your storages here or fetch from manager...
$stack->pushStorage(new ezcCacheStackStorageConfiguration('file', $fileStorage, 1000000, 0.5));
$stack->pushStorage(new ezcCacheStackStorageConfiguration('apc', $apcStorage, 1000, 0.3));
}
}
$stackOptions = array('bubbleUpOnRestore' => true, 'configurator' => 'myCustomConfigurator');
$stack = new ezcCacheStack('stack');
ezcCacheManager::createCache('stack', 'stack', 'ezcCacheStack', $stackOptions);
// ... somewhere else...
$stack = ezcCacheManager::getCache('stack');
public function testCacheManagerLocationEmpty()
{
$options = array('ttl' => 10);
ezcCacheManager::createCache('memory', null, 'ezcCacheStorageFileApcArray', $options);
try {
$storage = ezcCacheManager::getCache('memory');
$this->fail("Expected exception was not thrown");
} catch (ezcBaseFilePermissionException $e) {
$this->assertEquals("The file '/' can not be opened for writing. (Cache location is not a directory.)", $e->getMessage());
}
}
/**
* Override to add the "requestedResponseGroups" variable for every REST requests
*
* @see lib/ezc/MvcTools/src/interfaces/ezcMvcController::createResult()
*/
public function createResult()
{
$debug = ezpRestDebug::getInstance();
$debug->startTimer('GeneratingRestResult', 'RestController');
if (!self::$isCacheCreated) {
ezcCacheManager::createCache(self::CACHE_ID, $this->getCacheLocation(), 'ezpRestCacheStorageClusterObject', array('ttl' => $this->getActionTTL()));
self::$isCacheCreated = true;
}
$cache = ezcCacheManager::getCache(self::CACHE_ID);
$controllerCacheId = $this->generateCacheId();
$isCacheEnabled = $this->isCacheEnabled();
// Try to restore application cache.
// If expired or not yet available, generate it and store it
$cache->isCacheEnabled = $isCacheEnabled;
if (($res = $cache->restore($controllerCacheId)) === false) {
try {
$debug->log('Generating cache', ezcLog::DEBUG);
$debug->switchTimer('GeneratingCache', 'GeneratingRestResult');
$res = parent::createResult();
$resGroups = $this->getResponseGroups();
if (!empty($resGroups)) {
$res->variables['requestedResponseGroups'] = $resGroups;
}
if ($res instanceof ezpRestMvcResult) {
$res->responseGroups = $resGroups;
}
if ($isCacheEnabled) {
$cache->store($controllerCacheId, $res);
}
$debug->stopTimer('GeneratingCache');
} catch (Exception $e) {
$debug->log('Exception caught, aborting cache generation', ezcLog::DEBUG);
if ($isCacheEnabled) {
$cache->abortCacheGeneration();
}
throw $e;
}
}
// Add debug infos to output if debug is enabled
$debug->stopTimer('GeneratingRestResult');
if (ezpRestDebug::isDebugEnabled()) {
$res->variables['debug'] = $debug->getReport();
}
return $res;
}
}
// Central creation and configuration of the caches
// The ezcCacheManager just stores the configuration right now and
// performs sanity checks. The {@link ezcCacheStorage} instances
// will be created on demand, when you use them for the first time
// Configuration options for a cache {@link ezcCacheStorage}
$options = array('ttl' => 60 * 60 * 24 * 2);
// Create a cache named "content", that resides in /var/cache/content
// The cache instance will use the {@link ezcCacheStorageFileArray} class
// to store the cache data. The time-to-live for cache items is set as
// defined above.
ezcCacheManager::createCache('content', $basePath . '/content', 'ezcCacheStorageFileArray', $options);
// Create another cache, called "template" in /var/cache/templates.
// This cache will use the {@link ezcCacheStorageFilePlain} class to store
// cache data. It has the same TTL as the cache defined above.
ezcCacheManager::createCache('template', $basePath . '/templates', 'ezcCacheStorageFilePlain', $options);
// Somewhere in the application you can access the caches
// Get the instance of the cache called "content"
// Now the instance of {@link ezcCacheStorageFileArray is created and
// returned to be used. Next time you access this cache, the created
// instance will be reused.
$cache = ezcCacheManager::getCache('content');
// Specify any number of attributes to identify the cache item you want
// to store. This attributes can be used later to perform operations
// on a set of cache items, that share a common attribute.
$attributes = array('node' => 2, 'area' => 'admin', 'lang' => 'en-GB');
// This function is not part of the Cache package. You have to define
// unique IDs for your cache items yourself.
$id = getUniqueId();
// Initialize the data variable you want to restore
$data = '';
<?php
require 'ezc-setup.php';
@mkdir('/tmp/temp-location');
ezcCacheManager::createCache('identifier', '/tmp/temp-location', 'ezcCacheStorageFileEvalArray', array('ttl' => 30));
$cache = ezcCacheManager::getCache('identifier');
$myId = 'unique_id_1';
if (($data = $cache->restore($myId)) === false) {
$data = "Plain cache stored on " . date('Y-m-d, H:i:s');
$cache->store($myId, $data);
}
echo $data;
<?php
require_once 'tutorial_autoload.php';
$optionsPlain = array('ttl' => 30);
$optionsArray = array('ttl' => 45);
ezcCacheManager::createCache('plain', '/tmp/cache/plain', 'ezcCacheStorageFilePlain', $optionsPlain);
ezcCacheManager::createCache('array', '/tmp/cache/array', 'ezcCacheStorageFileArray', $optionsArray);
$myId = 'unique_id_2';
$cache = ezcCacheManager::getCache('plain');
if (($plainData = $cache->restore($myId)) === false) {
$plainData = "Plain cache stored on " . date('Y-m-d, H:m:s');
$cache->store($myId, $plainData);
sleep(2);
}
echo "Plain cache data:\n";
var_dump($plainData);
$cache = ezcCacheManager::getCache('array');
if (($arrayData = $cache->restore($myId)) === false) {
$arrayData = array($plainData, "Array cache stored on " . date('Y-m-d, H:m:s'), true, 23);
$cache->store($myId, $arrayData);
}
echo "Array cache data:\n";
var_dump($arrayData);
public function testCacheManagerLocationEmpty()
{
$options = array('ttl' => 10);
ezcCacheManager::createCache('cache', null, 'ezcCacheStorageApcPlain', $options);
$storage = ezcCacheManager::getCache('cache');
$storage->reset();
$storage->store('key', 'data');
$this->assertEquals('data', $storage->restore('key'));
}
public function testCacheBackendSingleConnection()
{
$options = array('host' => 'localhost', 'port' => 11211, 'ttl' => 10);
ezcCacheManager::createCache('cache-a', null, 'ezcCacheStorageMemcachePlain', $options);
ezcCacheManager::createCache('cache-b', null, 'ezcCacheStorageMemcachePlain', $options);
$storageA = ezcCacheManager::getCache('cache-a');
$storageA->reset();
$storageB = ezcCacheManager::getCache('cache-b');
$storageA->reset();
$backendA = $this->readAttribute($storageA, 'backend');
$backendB = $this->readAttribute($storageB, 'backend');
$memcacheA = $this->readAttribute($backendA, 'memcache');
$memcacheB = $this->readAttribute($backendB, 'memcache');
$this->assertSame($memcacheA, $memcacheB);
unset($storageA);
unset($storageA);
}
<?php
require_once 'tutorial_autoload.php';
$options = array('ttl' => 30, 'host' => 'localhost', 'port' => 11211);
ezcCacheManager::createCache('memcache', 'memcache', 'ezcCacheStorageMemcachePlain', $options);
$myId = 'unique_id_1';
$mySecondId = 'id_2';
$cache = ezcCacheManager::getCache('memcache');
if (($dataOfFirstItem = $cache->restore($myId)) === false) {
$dataOfFirstItem = "Plain cache stored on " . date('Y-m-d, H:i:s');
$cache->store($myId, $dataOfFirstItem);
}
if (($dataOfSecondItem = $cache->restore($mySecondId)) === false) {
$dataOfSecondItem = "Plain cache 2 stored on " . date('Y-m-d, H:i:s');
$cache->store($mySecondId, $dataOfSecondItem);
}
var_dump($dataOfFirstItem, $dataOfSecondItem);
public function testManagerCreateCache_Failure()
{
$id = 0;
// First try to create cache in invalid location.
$caughtException = false;
try {
$cache = ezcCacheManager::createCache($id, '/fckgw', $this->data[$id]);
$this->fail('Exception not thrown on invalid location </fckgw>.');
} catch (ezcBaseFileNotFoundException $e) {
$this->assertEquals("The cache location file '/fckgw' could not be found. (Does not exist or is no directory.)", $e->getMessage());
}
// Second try, allocate a cache succesfully
$location = $this->createTempDir($this->data[$id]);
$cache = ezcCacheManager::createCache($id, $location, $this->data[$id]);
// Use next cache class/location.
$id++;
$caughtException = false;
try {
// Use current ID with last IDs location
ezcCacheManager::createCache($id, $location, $this->data[$id]);
} catch (ezcCacheUsedLocationException $e) {
$caughtException = true;
}
if ($caughtException === false) {
$this->fail('Exception not thrown on used location <' . $location . '>.');
}
$this->removeTempDir($location);
// Use next cache class/location.
$id++;
$caughtException = false;
$location = $this->createTempDir($this->data[$id]);
try {
// Use current ID with non-existant cache class
ezcCacheManager::createCache($id, $location, 'Test');
} catch (ezcCacheInvalidStorageClassException $e) {
$caughtException = true;
}
if ($caughtException === false) {
$this->fail('Wrong exception thrown on invalid storage class <Test>.');
}
$this->removeTempDir($location);
}
<?php
require_once 'tutorial_autoload.php';
$options = array('ttl' => 30);
ezcCacheManager::createCache('simple', '/tmp/cache/plain', 'ezcCacheStorageFilePlain', $options);
$myId = 'unique_id_1';
$mySecondId = 'id_2';
$cache = ezcCacheManager::getCache('simple');
if (($dataOfFirstItem = $cache->restore($myId)) === false) {
$dataOfFirstItem = "Plain cache stored on " . date('Y-m-d, H:i:s');
$cache->store($myId, $dataOfFirstItem);
}
if (($dataOfSecondItem = $cache->restore($mySecondId)) === false) {
$dataOfSecondItem = "Plain cache 2 stored on " . date('Y-m-d, H:i:s');
$cache->store($mySecondId, $dataOfSecondItem);
}
var_dump($dataOfFirstItem, $dataOfSecondItem);
<?php
require_once 'tutorial_autoload.php';
$options = array('ttl' => 30);
ezcCacheManager::createCache('apc', 'apc', 'ezcCacheStorageApcPlain', $options);
$myId = 'unique_id_1';
$mySecondId = 'id_2';
$cache = ezcCacheManager::getCache('apc');
if (($dataOfFirstItem = $cache->restore($myId)) === false) {
$dataOfFirstItem = "Plain cache stored on " . date('Y-m-d, H:i:s');
$cache->store($myId, $dataOfFirstItem);
}
if (($dataOfSecondItem = $cache->restore($mySecondId)) === false) {
$dataOfSecondItem = "Plain cache 2 stored on " . date('Y-m-d, H:i:s');
$cache->store($mySecondId, $dataOfSecondItem);
}
var_dump($dataOfFirstItem, $dataOfSecondItem);
