/**
* Constructor
*
* @param array $options associative array of options
* @throws \Zend_Cache_Exception
*/
public function __construct(array $options = [])
{
if (!extension_loaded('eaccelerator')) {
\Zend_Cache::throwException('The eaccelerator extension must be loaded for using this backend !');
}
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!function_exists('zend_shm_cache_store')) {
Zend_Cache::throwException('Glitch_Cache_Backend_ZendShMem backend has to be used within Zend Server / Zend Platform environment.');
}
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
*/
public function __construct($options = array())
{
if (!extension_loaded('memcache')) {
Zend_Cache::throwException('The memcache extension must be loaded for using this backend !');
}
parent::__construct($options);
if (isset($options['servers'])) {
$value = $options['servers'];
if (isset($value['host'])) {
// in this case, $value seems to be a simple associative array (one server only)
$value = array(0 => $value);
// let's transform it into a classical array of associative arrays
}
$this->setOption('servers', $value);
}
$this->_memcache = new Memcache();
foreach ($this->_options['servers'] as $server) {
if (!array_key_exists('persistent', $server)) {
$server['persistent'] = Zend_Cache_Backend_Memcached::DEFAULT_PERSISTENT;
}
if (!array_key_exists('port', $server)) {
$server['port'] = Zend_Cache_Backend_Memcached::DEFAULT_PORT;
}
$this->_memcache->addServer($server['host'], $server['port'], $server['persistent']);
}
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = [])
{
if (!extension_loaded('redis')) {
Zend_Cache::throwException('The redis extension must be loaded for using this backend !');
}
parent::__construct($options);
$this->_redis = new Redis();
foreach ($this->_options['servers'] as $server) {
if (!array_key_exists('port', $server)) {
$server['port'] = self::DEFAULT_PORT;
}
if (!array_key_exists('host', $server)) {
$server['host'] = self::DEFAULT_HOST;
}
if (!array_key_exists('persistent', $server)) {
$server['persistent'] = self::DEFAULT_PERSISTENT;
}
if (!array_key_exists('dbindex', $server)) {
$server['dbindex'] = self::DEFAULT_DBINDEX;
}
if ($server['persistent']) {
$result = $this->_redis->pconnect($server['host'], $server['port']);
} else {
$result = $this->_redis->connect($server['host'], $server['port']);
}
if ($result) {
$this->_redis->select($server['dbindex']);
} else {
$this->_redis = null;
}
}
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!extension_loaded('xcache')) {
Zend_Cache::throwException('The xcache extension must be loaded for using this backend !');
}
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!extension_loaded('memcached')) {
Zend_Cache::throwException('The memcached extension must be loaded for using this backend !');
}
parent::__construct($options);
if (isset($this->_options['servers'])) {
$value = $this->_options['servers'];
if (isset($value['host'])) {
// in this case, $value seems to be a simple associative array (one server only)
$value = array(0 => $value);
// let's transform it into a classical array of associative arrays
}
$this->setOption('servers', $value);
}
if (array_key_exists('persistent', $this->_options) && is_string($this->_options['persistent'])) {
$this->_persistent_id = $this->createPersistentKey($this->_options['persistent'], $this->_options);
}
/*
* disabled the persistent connection for now, because it leads to unexpected results in
* hits & misses of the cache
*/
$this->_memcached = new Memcached();
//$this->_persistent_id);
$this->_memcached->setOption(Memcached::OPT_DISTRIBUTION, Memcached::DISTRIBUTION_CONSISTENT);
$this->_memcached->setOption(Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
/**
* Use the igbinary serialization protocol if compiled in pecl memcached module
*/
if (isset($this->_options['json']) && $this->_options['json'] === true && $this->_memcached->getOption(Memcached::HAVE_JSON)) {
$this->_memcached->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_JSON);
} else {
if (isset($this->_options['igbinary']) && $this->_options['igbinary'] === true && $this->_memcached->getOption(Memcached::HAVE_IGBINARY)) {
$this->_memcached->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY);
}
}
if (isset($this->_options['prefix']) && $this->_options['prefix'] != '') {
$this->_memcached->setOption(Memcached::OPT_PREFIX_KEY, $this->_options['prefix']);
}
if (isset($this->_options['compression']) && is_bool($this->_options['compression'])) {
$this->_memcached->setOption(Memcached::OPT_COMPRESSION, $this->_options['compression']);
}
/**
* When using persistent connections, do not re-add the servers and options
*/
if (!count($this->_memcached->getServerList())) {
// check servers array for options that are set
foreach ($this->_options['servers'] as &$server) {
if (!array_key_exists('port', $server)) {
$server['port'] = self::DEFAULT_PORT;
}
if (!array_key_exists('weight', $server)) {
$server['weight'] = self::DEFAULT_WEIGHT;
}
$this->_memcached->addServer($server['host'], $server['port'], $server['weight']);
}
//$this->_memcached->addServers($this->_options['servers']);
}
}
/**
* Contruct Zend_Cache Redis backend
*
* @param array $options Options
*
* servers - Array of servers: array(
* array('host' => '127.0.0.1', 'port' => 6379, 'weight' => 1, 'password' => '123'),
* array('host' => '127.0.0.1', 'port' => 6380, 'weight' => 2)
* )
* serializer - Callback function for serialization.
* You may use PHP extensions like igbinary (http://opensource.dynamoid.com/)
* or you personal function.
* For default php function serialize.
* unserializer - Unserialize callback.
* keyDistributor - Algorithm of keys distribution on redis servers.
* For default 'consistentHashing' which implement
* consistent hashing algorithm (http://weblogs.java.net/blog/tomwhite/archive/2007/11/consistent_hash.html)
* You may use basic 'crc32' (crc32(key) % servers_count) algorithm
* or you personal implementation (option value - name of class
* which implements Rediska_KeyDistributor_Interface).
*
*/
public function __construct(array $options = array())
{
parent::__construct($options);
if (isset($options['namespace'])) {
Zend_Cache::throwException('Namespace must definded in front end options (cache_id_prefix)');
}
$this->_rediska = new Rediska($options);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!extension_loaded('redis')) {
Zend_Cache::throwException('The redis extension must be loaded for using this backend !');
}
$this->_redis = new Redis();
parent::__construct($options);
}
public function __construct(array $options = array())
{
if (isset($options['cache_id_prefix'])) {
throw new Kwf_Exception("Unsupported optoin for Apcu backend: cache_id_prefix");
}
if (!extension_loaded('apcu')) {
Zend_Cache::throwException('The apcu extension must be loaded for using this backend !');
}
parent::__construct($options);
}
/**
* @param array $options
*/
public function __construct(array $options = array())
{
if (!extension_loaded('mongo') || !version_compare(\Mongo::VERSION, '1.2.11', '>=')) {
\Zend_Cache::throwException("At least 1.2.11 version of 'mongo' extension is required for using MongoDb cache backend");
}
if (empty($options['db'])) {
\Zend_Cache::throwException("'db' option is not specified");
}
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct($options = array())
{
if ($options['backend'] instanceof Zend_Cache_Backend_Interface || $options['backend'] instanceof Tid_Zend_Cache_Backend_Abstract) {
$this->_backend = $options['backend'];
} else {
Zend_Cache::throwException('The backend option is not correctly set!');
}
$this->_id = '__' . get_class($this) . '__';
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!empty($options['socket'])) {
$options['connmode'] = self::CONN_SOCKET;
}
if (!extension_loaded('redis')) {
Zend_Cache::throwException('The redis extension must be loaded for using this backend !');
}
$this->_redis = new Redis();
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
*/
public function __construct($options = array())
{
if (!isset($options['cacheDBCompletePath'])) {
Zend_Cache::throwException('cacheDBCompletePath option has to set');
}
$this->_db = @sqlite_open($options['cacheDBCompletePath']);
if (!$this->_db) {
Zend_Cache::throwException("Impossible to open " . $options['cacheDBCompletePath'] . " cache DB file");
}
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options Associative array of options
* @throws Zend_cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
parent::__construct($options);
if (is_null($this->_options['cache_db_complete_path'])) {
Zend_Cache::throwException('cache_db_complete_path option has to set');
}
if (!extension_loaded('sqlite')) {
Zend_Cache::throwException("Cannot use SQLite storage because the 'sqlite' extension is not loaded in the current PHP environment");
}
$this->_getConnection();
}
/**
* Constructor
*
* @param array $options associative array of options
*/
public function __construct($options = array())
{
parent::__construct($options);
if (empty($this->_options['adapter_callback'])) {
if (!$this->_options['adapter'] instanceof Zend_Db_Adapter_Abstract) {
Zend_Cache::throwException('Option "adapter" should be declared and extend Zend_Db_Adapter_Abstract!');
}
}
if (empty($this->_options['data_table']) || empty($this->_options['tags_table'])) {
Zend_Cache::throwException('Options "data_table" and "tags_table" should be declared!');
}
}
/**
* @return void
*/
public function __construct($options)
{
if (!extension_loaded('mongo')) {
Zend_Cache::throwException('The MongoDB extension must be loaded for using this backend !');
}
parent::__construct($options);
// Merge the options passed in; overridding any default options
$this->_options = array_merge($this->_options, $options);
$this->_conn = new Mongo($this->_options['host'], $this->_options['port'], $this->_options['persistent']);
$this->_db = $this->_conn->selectDB($this->_options['dbname']);
$this->_collection = $this->_db->selectCollection($this->_options['collection']);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
$this->_backendOptions = $options;
if (isset($this->_backendOptions['tagStorage'])) {
$this->setOption('tagStorage', $this->_backendOptions['tagStorage']);
unset($this->_backendOptions['tagStorage']);
}
if (isset($this->_backendOptions['backendClass'])) {
$this->setOption('backendClass', $this->_backendOptions['backendClass']);
unset($this->_backendOptions['backendClass']);
}
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!extension_loaded('memcached')) {
Zend_Cache::throwException('The memcached extension must be loaded for using this backend !');
}
// override default client options
$this->_options['client'] = array(Memcached::OPT_DISTRIBUTION => Memcached::DISTRIBUTION_CONSISTENT, Memcached::OPT_HASH => Memcached::HASH_MD5, Memcached::OPT_LIBKETAMA_COMPATIBLE => true);
parent::__construct($options);
if (isset($this->_options['servers'])) {
$value = $this->_options['servers'];
if (isset($value['host'])) {
// in this case, $value seems to be a simple associative array (one server only)
$value = array(0 => $value);
// let's transform it into a classical array of associative arrays
}
$this->setOption('servers', $value);
}
$this->_memcache = new Memcached();
// setup memcached client options
foreach ($this->_options['client'] as $name => $value) {
$optId = null;
if (is_int($name)) {
$optId = $name;
} else {
$optConst = 'Memcached::OPT_' . strtoupper($name);
if (defined($optConst)) {
$optId = constant($optConst);
} else {
$this->_log("Unknown memcached client option '{$name}' ({$optConst})");
}
}
if ($optId) {
if (!$this->_memcache->setOption($optId, $value)) {
$this->_log("Setting memcached client option '{$optId}' failed");
}
}
}
// setup memcached servers
$servers = array();
foreach ($this->_options['servers'] as $server) {
if (!array_key_exists('port', $server)) {
$server['port'] = self::DEFAULT_PORT;
}
if (!array_key_exists('weight', $server)) {
$server['weight'] = self::DEFAULT_WEIGHT;
}
$servers[] = array($server['host'], $server['port'], $server['weight']);
}
$this->_memcache->addServers($servers);
}
/**
* @return void
*/
public function __construct($options)
{
if (!extension_loaded('mongo')) {
Zend_Cache::throwException('The MongoDB extension must be loaded for using this backend !');
}
parent::__construct($options);
// Merge the options passed in; overridding any default options
$this->_options = array_merge($this->_options, $options);
$this->_conn = new Mongo('mongodb://' . $this->_options['host'] . ':' . $this->_options['port'], array());
$this->_db = $this->_conn->selectDB($this->_options['dbname']);
$this->_collection = $this->_db->selectCollection($this->_options['collection']);
$this->_collection->ensureIndex(array('t' => 1), array('background' => true));
$this->_collection->ensureIndex(array('expire' => 1), array('background' => true));
}
/**
* Note that we use TTL Collections to have the Mongo deamon automatically clean
* expired entries.
*
* @link http://docs.mongodb.org/manual/tutorial/expire-data/
* @param array $options
*/
public function __construct(array $options = array())
{
if (!extension_loaded('mongo')) {
Zend_Cache::throwException('The MongoDB extension must be loaded for using this backend !');
}
parent::__construct($options);
// Merge the options passed in; overriding any default options
$this->_options = array_merge($this->_options, $options);
$conn = new \MongoClient($this->_getServerConnectionUrl());
$this->_database = $conn->{$this->_options['dbname']};
$this->_collection = $this->_database->selectCollection($this->_options['collection']);
$this->_collection->createIndex(array('tags' => 1), array('background' => true));
$this->_collection->createIndex(array('expires_at' => 1), array('background' => true, 'expireAfterSeconds' => 0));
}
/**
* Constructor
*
* @param array $options associative array of options
*/
public function __construct($options = [])
{
parent::__construct($options);
if (empty($this->_options['adapter_callback'])) {
if (!$this->_options['adapter'] instanceof \Zend_Db_Adapter_Abstract) {
\Zend_Cache::throwException('Option "adapter" should be declared and extend \\Zend_Db_Adapter_Abstract!');
}
}
if (empty($this->_options['data_table']) && empty($this->_options['data_table_callback'])) {
\Zend_Cache::throwException('Option "data_table" or "data_table_callback" should be declared!');
}
if (empty($this->_options['tags_table']) && empty($this->_options['tags_table_callback'])) {
\Zend_Cache::throwException('Option "tags_table" or "tags_table_callback" should be declared!');
}
}
/**
* Constructor
*
* @param array $options associative array of options
*/
public function __construct($options = [])
{
parent::__construct($options);
if (empty($this->_options['adapter_callback'])) {
if (!$this->_options['adapter'] instanceof \Magento\Framework\DB\Adapter\AdapterInterface) {
\Zend_Cache::throwException('Option "adapter" should be declared and extend \\Magento\\Framework\\DB\\Adapter\\AdapterInterface!');
}
}
if (empty($this->_options['data_table']) && empty($this->_options['data_table_callback'])) {
\Zend_Cache::throwException('Option "data_table" or "data_table_callback" should be declared!');
}
if (empty($this->_options['tags_table']) && empty($this->_options['tags_table_callback'])) {
\Zend_Cache::throwException('Option "tags_table" or "tags_table_callback" should be declared!');
}
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct($options = array())
{
parent::__construct($options);
if (is_array($options['backend'])) {
$backendClass = $options['backend']['class'];
$this->_backend = new $backendClass($options['backend']['options']);
} else {
if ($options['backend'] instanceof Zend_Cache_Backend_Interface) {
$this->_backend = $options['backend'];
} else {
Zend_Cache::throwException('The backend option is not correctly set!');
}
}
if (!is_array($options['table'])) {
Zend_Cache::throwException('The table option is not correctly set!');
}
}
/**
* Constructor
* Validate that the Zend Platform is loaded and licensed
*
* @param array $options associative array of options
*/
public function __construct($options = array())
{
if (!function_exists('accelerator_license_info')) {
Zend_Cache::throwException('The Zend Platform extension must be loaded for using this backend !');
}
if (!function_exists('accelerator_get_configuration')) {
$licenseInfo = accelerator_license_info();
Zend_Cache::throwException('The Zend Platform extension is not loaded correctly: ' . $licenseInfo['failure_reason']);
}
$accConf = accelerator_get_configuration();
if (@(!$accConf['output_cache_licensed'])) {
Zend_Cache::throwException('The Zend Platform extension does not have the proper license to use content caching features');
}
if (@(!$accConf['output_cache_enabled'])) {
Zend_Cache::throwException('The Zend Platform content caching feature must be enabled for using this backend, set the \'zend_accelerator.output_cache_enabled\' directive to On !');
}
if (!is_writable($accConf['output_cache_dir'])) {
Zend_Cache::throwException('The cache copies directory \'' . ini_get('zend_accelerator.output_cache_dir') . '\' must be writable !');
}
parent::__construct($options);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!extension_loaded('redis')) {
Zend_Cache::throwException('The redis extension must be loaded for using this backend !');
}
parent::__construct($options);
if (isset($this->_options['servers'])) {
$value = $this->_options['servers'];
if (isset($value['host'])) {
// in this case, $value seems to be a simple associative array (one server only)
$value = array(0 => $value);
// let's transform it into a classical array of associative arrays
}
$this->setOption('servers', $value);
}
$this->_redis = new Redis();
foreach ($this->_options['servers'] as $server) {
if (!(isset($server['port']) || array_key_exists('port', $server))) {
$server['port'] = self::DEFAULT_PORT;
}
if (!(isset($server['persistent']) || array_key_exists('persistent', $server))) {
$server['persistent'] = self::DEFAULT_PERSISTENT;
}
#if (!(isset($server['weight']) || array_key_exists('weight', $server))) {
# $server['weight'] = self::DEFAULT_WEIGHT;
#}
if (!(isset($server['timeout']) || array_key_exists('timeout', $server))) {
$server['timeout'] = self::DEFAULT_TIMEOUT;
}
if (!(isset($server['prefix']) || array_key_exists('prefix', $server))) {
$server['prefix'] = self::DEFAULT_PREFIX;
}
$this->_redis->connect($server['host'], $server['port'], $server['timeout']);
}
$this->_redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
$this->_redis->setOption(Redis::OPT_PREFIX, $server['prefix']);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!extension_loaded('redis')) {
Zend_Cache::throwException('The redis extension must be loaded for using this backend !');
}
parent::__construct($options);
$this->_redis = new Redis();
// setup memcached client options
foreach ($this->_options['client'] as $name => $value) {
$optId = null;
if (is_int($name)) {
$optId = $name;
} else {
$optConst = 'Redis::OPT_' . strtoupper($name);
if (defined($optConst)) {
$optId = constant($optConst);
} else {
$this->_log("Unknown redis client option '{$name}' ({$optConst})");
}
}
if ($optId) {
if (!$this->_redis->setOption($optId, $value)) {
$this->_log("Setting redis client option '{$optId}' failed");
}
}
}
$server = array();
$server = $this->_options['server'];
if (!array_key_exists('port', $server)) {
$server['port'] = self::DEFAULT_PORT;
}
if (!array_key_exists('timeout', $server)) {
$server['timeout'] = self::DEFAULT_TIMEOUT;
}
$this->_redis->connect($server['host'], $server['port'], $server['timeout']);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
parent::__construct($options);
if ($this->_options['cache_dir'] !== null) {
// particular case for this option
$this->setCacheDir($this->_options['cache_dir']);
} else {
$this->setCacheDir(self::getTmpDir() . DIRECTORY_SEPARATOR, false);
}
if (isset($this->_options['file_name_prefix'])) {
// particular case for this option
if (!preg_match('~^[\\w]+$~', $this->_options['file_name_prefix'])) {
Zend_Cache::throwException('Invalid file_name_prefix : must use only [a-zA-A0-9_]');
}
}
if ($this->_options['metadatas_array_max_size'] < 10) {
Zend_Cache::throwException('Invalid metadatas_array_max_size, must be > 10');
}
if (isset($options['hashed_directory_umask']) && is_string($options['hashed_directory_umask'])) {
// See #ZF-4422
$this->_options['hashed_directory_umask'] = octdec($this->_options['hashed_directory_umask']);
}
if (isset($options['cache_file_umask']) && is_string($options['cache_file_umask'])) {
// See #ZF-4422
$this->_options['cache_file_umask'] = octdec($this->_options['cache_file_umask']);
}
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
if (!extension_loaded('memcache')) {
Zend_Cache::throwException('The memcache extension must be loaded for using this backend !');
}
parent::__construct($options);
if (isset($this->_options['servers'])) {
$value = $this->_options['servers'];
if (isset($value['host'])) {
// in this case, $value seems to be a simple associative array (one server only)
$value = array(0 => $value);
// let's transform it into a classical array of associative arrays
}
$this->setOption('servers', $value);
}
$this->_memcache = new Memcache();
foreach ($this->_options['servers'] as $server) {
if (!array_key_exists('port', $server)) {
$server['port'] = self::DEFAULT_PORT;
}
if (!array_key_exists('persistent', $server)) {
$server['persistent'] = self::DEFAULT_PERSISTENT;
}
if (!array_key_exists('weight', $server)) {
$server['weight'] = self::DEFAULT_WEIGHT;
}
if (!array_key_exists('timeout', $server)) {
$server['timeout'] = self::DEFAULT_TIMEOUT;
}
if (!array_key_exists('retry_interval', $server)) {
$server['retry_interval'] = self::DEFAULT_RETRY_INTERVAL;
}
if (!array_key_exists('status', $server)) {
$server['status'] = self::DEFAULT_STATUS;
}
if (!array_key_exists('failure_callback', $server)) {
$server['failure_callback'] = self::DEFAULT_FAILURE_CALLBACK;
}
if ($this->_options['compatibility']) {
// No status for compatibility mode (#ZF-5887)
$this->_memcache->addServer($server['host'], $server['port'], $server['persistent'], $server['weight'], $server['timeout'], $server['retry_interval']);
} else {
$this->_memcache->addServer($server['host'], $server['port'], $server['persistent'], $server['weight'], $server['timeout'], $server['retry_interval'], $server['status'], $server['failure_callback']);
}
}
}
/**
* Constructor
*
* @param array $options Associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct(array $options = array())
{
parent::__construct($options);
if ($this->_options['slow_backend'] === null) {
Zend_Cache::throwException('slow_backend option has to set');
} elseif ($this->_options['slow_backend'] instanceof Zend_Cache_Backend_ExtendedInterface) {
$this->_slowBackend = $this->_options['slow_backend'];
} else {
$this->_slowBackend = Zend_Cache::_makeBackend($this->_options['slow_backend'], $this->_options['slow_backend_options'], $this->_options['slow_backend_custom_naming'], $this->_options['slow_backend_autoload']);
if (!in_array('Zend_Cache_Backend_ExtendedInterface', class_implements($this->_slowBackend))) {
Zend_Cache::throwException('slow_backend must implement the Zend_Cache_Backend_ExtendedInterface interface');
}
}
if ($this->_options['fast_backend'] === null) {
Zend_Cache::throwException('fast_backend option has to set');
} elseif ($this->_options['fast_backend'] instanceof Zend_Cache_Backend_ExtendedInterface) {
$this->_fastBackend = $this->_options['fast_backend'];
} else {
$this->_fastBackend = Zend_Cache::_makeBackend($this->_options['fast_backend'], $this->_options['fast_backend_options'], $this->_options['fast_backend_custom_naming'], $this->_options['fast_backend_autoload']);
if (!in_array('Zend_Cache_Backend_ExtendedInterface', class_implements($this->_fastBackend))) {
Zend_Cache::throwException('fast_backend must implement the Zend_Cache_Backend_ExtendedInterface interface');
}
}
$this->_slowBackend->setDirectives($this->_directives);
$this->_fastBackend->setDirectives($this->_directives);
}
/**
* Constructor
*
* @param array $options associative array of options
* @throws Zend_Cache_Exception
*/
public function __construct(array $options = array())
{
parent::__construct($options);
if ($this->_options['cache_dir'] !== null) {
// particular case for this option
$this->setCacheDir($this->_options['cache_dir']);
} else {
$this->setCacheDir(self::getTmpDir() . DIRECTORY_SEPARATOR, false);
}
if (isset($this->_options['file_name_prefix'])) {
// particular case for this option
if (!preg_match('~^[a-zA-Z0-9_]+$~D', $this->_options['file_name_prefix'])) {
Zend_Cache::throwException('Invalid file_name_prefix : must use only [a-zA-Z0-9_]');
}
}
if ($this->_options['metadatas_array_max_size'] < 10) {
Zend_Cache::throwException('Invalid metadatas_array_max_size, must be > 10');
}
if (isset($options['hashed_directory_umask'])) {
// See #ZF-12047
trigger_error("'hashed_directory_umask' is deprecated -> please use 'hashed_directory_perm' instead", E_USER_NOTICE);
if (!isset($options['hashed_directory_perm'])) {
$options['hashed_directory_perm'] = $options['hashed_directory_umask'];
}
}
if (isset($options['hashed_directory_perm']) && is_string($options['hashed_directory_perm'])) {
// See #ZF-4422
$this->_options['hashed_directory_perm'] = octdec($this->_options['hashed_directory_perm']);
}
if (isset($options['cache_file_umask'])) {
// See #ZF-12047
trigger_error("'cache_file_umask' is deprecated -> please use 'cache_file_perm' instead", E_USER_NOTICE);
if (!isset($options['cache_file_perm'])) {
$options['cache_file_perm'] = $options['cache_file_umask'];
}
}
if (isset($options['cache_file_perm']) && is_string($options['cache_file_perm'])) {
// See #ZF-4422
$this->_options['cache_file_perm'] = octdec($this->_options['cache_file_perm']);
}
}
