/** * 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']); } }