PageRenderTime 59ms CodeModel.GetById 24ms app.highlight 25ms RepoModel.GetById 2ms app.codeStats 0ms

/Cache/Core.php

https://bitbucket.org/bigstylee/zend-framework
PHP | 765 lines | 382 code | 64 blank | 319 comment | 80 complexity | 232bc3c6fae5f7d54e7338b949e174c1 MD5 | raw file
  1<?php
  2/**
  3 * Zend Framework
  4 *
  5 * LICENSE
  6 *
  7 * This source file is subject to the new BSD license that is bundled
  8 * with this package in the file LICENSE.txt.
  9 * It is also available through the world-wide-web at this URL:
 10 * http://framework.zend.com/license/new-bsd
 11 * If you did not receive a copy of the license and are unable to
 12 * obtain it through the world-wide-web, please send an email
 13 * to license@zend.com so we can send you a copy immediately.
 14 *
 15 * @category   Zend
 16 * @package    Zend_Cache
 17 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 18 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 19 * @version    $Id: Core.php 24989 2012-06-21 07:24:13Z mabe $
 20 */
 21
 22
 23/**
 24 * @package    Zend_Cache
 25 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 26 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 27 */
 28class Zend_Cache_Core
 29{
 30    /**
 31     * Messages
 32     */
 33    const BACKEND_NOT_SUPPORTS_TAG = 'tags are not supported by the current backend';
 34    const BACKEND_NOT_IMPLEMENTS_EXTENDED_IF = 'Current backend doesn\'t implement the Zend_Cache_Backend_ExtendedInterface, so this method is not available';
 35
 36    /**
 37     * Backend Object
 38     *
 39     * @var Zend_Cache_Backend_Interface $_backend
 40     */
 41    protected $_backend = null;
 42
 43    /**
 44     * Available options
 45     *
 46     * ====> (boolean) write_control :
 47     * - Enable / disable write control (the cache is read just after writing to detect corrupt entries)
 48     * - Enable write control will lightly slow the cache writing but not the cache reading
 49     * Write control can detect some corrupt cache files but maybe it's not a perfect control
 50     *
 51     * ====> (boolean) caching :
 52     * - Enable / disable caching
 53     * (can be very useful for the debug of cached scripts)
 54     *
 55     * =====> (string) cache_id_prefix :
 56     * - prefix for cache ids (namespace)
 57     *
 58     * ====> (boolean) automatic_serialization :
 59     * - Enable / disable automatic serialization
 60     * - It can be used to save directly datas which aren't strings (but it's slower)
 61     *
 62     * ====> (int) automatic_cleaning_factor :
 63     * - Disable / Tune the automatic cleaning process
 64     * - The automatic cleaning process destroy too old (for the given life time)
 65     *   cache files when a new cache file is written :
 66     *     0               => no automatic cache cleaning
 67     *     1               => systematic cache cleaning
 68     *     x (integer) > 1 => automatic cleaning randomly 1 times on x cache write
 69     *
 70     * ====> (int) lifetime :
 71     * - Cache lifetime (in seconds)
 72     * - If null, the cache is valid forever.
 73     *
 74     * ====> (boolean) logging :
 75     * - If set to true, logging is activated (but the system is slower)
 76     *
 77     * ====> (boolean) ignore_user_abort
 78     * - If set to true, the core will set the ignore_user_abort PHP flag inside the
 79     *   save() method to avoid cache corruptions in some cases (default false)
 80     *
 81     * @var array $_options available options
 82     */
 83    protected $_options = array(
 84        'write_control'             => true,
 85        'caching'                   => true,
 86        'cache_id_prefix'           => null,
 87        'automatic_serialization'   => false,
 88        'automatic_cleaning_factor' => 10,
 89        'lifetime'                  => 3600,
 90        'logging'                   => false,
 91        'logger'                    => null,
 92        'ignore_user_abort'         => false
 93    );
 94
 95    /**
 96     * Array of options which have to be transfered to backend
 97     *
 98     * @var array $_directivesList
 99     */
100    protected static $_directivesList = array('lifetime', 'logging', 'logger');
101
102    /**
103     * Not used for the core, just a sort a hint to get a common setOption() method (for the core and for frontends)
104     *
105     * @var array $_specificOptions
106     */
107    protected $_specificOptions = array();
108
109    /**
110     * Last used cache id
111     *
112     * @var string $_lastId
113     */
114    private $_lastId = null;
115
116    /**
117     * True if the backend implements Zend_Cache_Backend_ExtendedInterface
118     *
119     * @var boolean $_extendedBackend
120     */
121    protected $_extendedBackend = false;
122
123    /**
124     * Array of capabilities of the backend (only if it implements Zend_Cache_Backend_ExtendedInterface)
125     *
126     * @var array
127     */
128    protected $_backendCapabilities = array();
129
130    /**
131     * Constructor
132     *
133     * @param  array|Zend_Config $options Associative array of options or Zend_Config instance
134     * @throws Zend_Cache_Exception
135     * @return void
136     */
137    public function __construct($options = array())
138    {
139        if ($options instanceof Zend_Config) {
140            $options = $options->toArray();
141        }
142        if (!is_array($options)) {
143            Zend_Cache::throwException("Options passed were not an array"
144            . " or Zend_Config instance.");
145        }
146        while (list($name, $value) = each($options)) {
147            $this->setOption($name, $value);
148        }
149        $this->_loggerSanity();
150    }
151
152    /**
153     * Set options using an instance of type Zend_Config
154     *
155     * @param Zend_Config $config
156     * @return Zend_Cache_Core
157     */
158    public function setConfig(Zend_Config $config)
159    {
160        $options = $config->toArray();
161        while (list($name, $value) = each($options)) {
162            $this->setOption($name, $value);
163        }
164        return $this;
165    }
166
167    /**
168     * Set the backend
169     *
170     * @param  Zend_Cache_Backend $backendObject
171     * @throws Zend_Cache_Exception
172     * @return void
173     */
174    public function setBackend(Zend_Cache_Backend $backendObject)
175    {
176        $this->_backend= $backendObject;
177        // some options (listed in $_directivesList) have to be given
178        // to the backend too (even if they are not "backend specific")
179        $directives = array();
180        foreach (Zend_Cache_Core::$_directivesList as $directive) {
181            $directives[$directive] = $this->_options[$directive];
182        }
183        $this->_backend->setDirectives($directives);
184        if (in_array('Zend_Cache_Backend_ExtendedInterface', class_implements($this->_backend))) {
185            $this->_extendedBackend = true;
186            $this->_backendCapabilities = $this->_backend->getCapabilities();
187        }
188
189    }
190
191    /**
192     * Returns the backend
193     *
194     * @return Zend_Cache_Backend backend object
195     */
196    public function getBackend()
197    {
198        return $this->_backend;
199    }
200
201    /**
202     * Public frontend to set an option
203     *
204     * There is an additional validation (relatively to the protected _setOption method)
205     *
206     * @param  string $name  Name of the option
207     * @param  mixed  $value Value of the option
208     * @throws Zend_Cache_Exception
209     * @return void
210     */
211    public function setOption($name, $value)
212    {
213        if (!is_string($name)) {
214            Zend_Cache::throwException("Incorrect option name!");
215        }
216        $name = strtolower($name);
217        if (array_key_exists($name, $this->_options)) {
218            // This is a Core option
219            $this->_setOption($name, $value);
220            return;
221        }
222        if (array_key_exists($name, $this->_specificOptions)) {
223            // This a specic option of this frontend
224            $this->_specificOptions[$name] = $value;
225            return;
226        }
227    }
228
229    /**
230     * Public frontend to get an option value
231     *
232     * @param  string $name  Name of the option
233     * @throws Zend_Cache_Exception
234     * @return mixed option value
235     */
236    public function getOption($name)
237    {
238        $name = strtolower($name);
239
240        if (array_key_exists($name, $this->_options)) {
241            // This is a Core option
242            return $this->_options[$name];
243        }
244
245        if (array_key_exists($name, $this->_specificOptions)) {
246            // This a specic option of this frontend
247            return $this->_specificOptions[$name];
248        }
249
250        Zend_Cache::throwException("Incorrect option name : $name");
251    }
252
253    /**
254     * Set an option
255     *
256     * @param  string $name  Name of the option
257     * @param  mixed  $value Value of the option
258     * @throws Zend_Cache_Exception
259     * @return void
260     */
261    private function _setOption($name, $value)
262    {
263        if (!is_string($name) || !array_key_exists($name, $this->_options)) {
264            Zend_Cache::throwException("Incorrect option name : $name");
265        }
266        if ($name == 'lifetime' && empty($value)) {
267            $value = null;
268        }
269        $this->_options[$name] = $value;
270    }
271
272    /**
273     * Force a new lifetime
274     *
275     * The new value is set for the core/frontend but for the backend too (directive)
276     *
277     * @param  int $newLifetime New lifetime (in seconds)
278     * @return void
279     */
280    public function setLifetime($newLifetime)
281    {
282        $this->_options['lifetime'] = $newLifetime;
283        $this->_backend->setDirectives(array(
284            'lifetime' => $newLifetime
285        ));
286    }
287
288    /**
289     * Test if a cache is available for the given id and (if yes) return it (false else)
290     *
291     * @param  string  $id                     Cache id
292     * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
293     * @param  boolean $doNotUnserialize       Do not serialize (even if automatic_serialization is true) => for internal use
294     * @return mixed|false Cached datas
295     */
296    public function load($id, $doNotTestCacheValidity = false, $doNotUnserialize = false)
297    {
298        if (!$this->_options['caching']) {
299            return false;
300        }
301        $id = $this->_id($id); // cache id may need prefix
302        $this->_lastId = $id;
303        self::_validateIdOrTag($id);
304
305        $this->_log("Zend_Cache_Core: load item '{$id}'", 7);
306        $data = $this->_backend->load($id, $doNotTestCacheValidity);
307        if ($data===false) {
308            // no cache available
309            return false;
310        }
311        if ((!$doNotUnserialize) && $this->_options['automatic_serialization']) {
312            // we need to unserialize before sending the result
313            return unserialize($data);
314        }
315        return $data;
316    }
317
318    /**
319     * Test if a cache is available for the given id
320     *
321     * @param  string $id Cache id
322     * @return int|false Last modified time of cache entry if it is available, false otherwise
323     */
324    public function test($id)
325    {
326        if (!$this->_options['caching']) {
327            return false;
328        }
329        $id = $this->_id($id); // cache id may need prefix
330        self::_validateIdOrTag($id);
331        $this->_lastId = $id;
332
333        $this->_log("Zend_Cache_Core: test item '{$id}'", 7);
334        return $this->_backend->test($id);
335    }
336
337    /**
338     * Save some data in a cache
339     *
340     * @param  mixed $data           Data to put in cache (can be another type than string if automatic_serialization is on)
341     * @param  string $id             Cache id (if not set, the last cache id will be used)
342     * @param  array $tags           Cache tags
343     * @param  int $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
344     * @param  int   $priority         integer between 0 (very low priority) and 10 (maximum priority) used by some particular backends
345     * @throws Zend_Cache_Exception
346     * @return boolean True if no problem
347     */
348    public function save($data, $id = null, $tags = array(), $specificLifetime = false, $priority = 8)
349    {
350        if (!$this->_options['caching']) {
351            return true;
352        }
353        if ($id === null) {
354            $id = $this->_lastId;
355        } else {
356            $id = $this->_id($id);
357        }
358        self::_validateIdOrTag($id);
359        self::_validateTagsArray($tags);
360        if ($this->_options['automatic_serialization']) {
361            // we need to serialize datas before storing them
362            $data = serialize($data);
363        } else {
364            if (!is_string($data)) {
365                Zend_Cache::throwException("Datas must be string or set automatic_serialization = true");
366            }
367        }
368
369        // automatic cleaning
370        if ($this->_options['automatic_cleaning_factor'] > 0) {
371            $rand = rand(1, $this->_options['automatic_cleaning_factor']);
372            if ($rand==1) {
373                //  new way                 || deprecated way
374                if ($this->_extendedBackend || method_exists($this->_backend, 'isAutomaticCleaningAvailable')) {
375                    $this->_log("Zend_Cache_Core::save(): automatic cleaning running", 7);
376                    $this->clean(Zend_Cache::CLEANING_MODE_OLD);
377                } else {
378                    $this->_log("Zend_Cache_Core::save(): automatic cleaning is not available/necessary with current backend", 4);
379                }
380            }
381        }
382
383        $this->_log("Zend_Cache_Core: save item '{$id}'", 7);
384        if ($this->_options['ignore_user_abort']) {
385            $abort = ignore_user_abort(true);
386        }
387        if (($this->_extendedBackend) && ($this->_backendCapabilities['priority'])) {
388            $result = $this->_backend->save($data, $id, $tags, $specificLifetime, $priority);
389        } else {
390            $result = $this->_backend->save($data, $id, $tags, $specificLifetime);
391        }
392        if ($this->_options['ignore_user_abort']) {
393            ignore_user_abort($abort);
394        }
395
396        if (!$result) {
397            // maybe the cache is corrupted, so we remove it !
398            $this->_log("Zend_Cache_Core::save(): failed to save item '{$id}' -> removing it", 4);
399            $this->_backend->remove($id);
400            return false;
401        }
402
403        if ($this->_options['write_control']) {
404            $data2 = $this->_backend->load($id, true);
405            if ($data!=$data2) {
406                $this->_log("Zend_Cache_Core::save(): write control of item '{$id}' failed -> removing it", 4);
407                $this->_backend->remove($id);
408                return false;
409            }
410        }
411
412        return true;
413    }
414
415    /**
416     * Remove a cache
417     *
418     * @param  string $id Cache id to remove
419     * @return boolean True if ok
420     */
421    public function remove($id)
422    {
423        if (!$this->_options['caching']) {
424            return true;
425        }
426        $id = $this->_id($id); // cache id may need prefix
427        self::_validateIdOrTag($id);
428
429        $this->_log("Zend_Cache_Core: remove item '{$id}'", 7);
430        return $this->_backend->remove($id);
431    }
432
433    /**
434     * Clean cache entries
435     *
436     * Available modes are :
437     * 'all' (default)  => remove all cache entries ($tags is not used)
438     * 'old'            => remove too old cache entries ($tags is not used)
439     * 'matchingTag'    => remove cache entries matching all given tags
440     *                     ($tags can be an array of strings or a single string)
441     * 'notMatchingTag' => remove cache entries not matching one of the given tags
442     *                     ($tags can be an array of strings or a single string)
443     * 'matchingAnyTag' => remove cache entries matching any given tags
444     *                     ($tags can be an array of strings or a single string)
445     *
446     * @param  string       $mode
447     * @param  array|string $tags
448     * @throws Zend_Cache_Exception
449     * @return boolean True if ok
450     */
451    public function clean($mode = 'all', $tags = array())
452    {
453        if (!$this->_options['caching']) {
454            return true;
455        }
456        if (!in_array($mode, array(Zend_Cache::CLEANING_MODE_ALL,
457                                   Zend_Cache::CLEANING_MODE_OLD,
458                                   Zend_Cache::CLEANING_MODE_MATCHING_TAG,
459                                   Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG,
460                                   Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG))) {
461            Zend_Cache::throwException('Invalid cleaning mode');
462        }
463        self::_validateTagsArray($tags);
464
465        return $this->_backend->clean($mode, $tags);
466    }
467
468    /**
469     * Return an array of stored cache ids which match given tags
470     *
471     * In case of multiple tags, a logical AND is made between tags
472     *
473     * @param array $tags array of tags
474     * @return array array of matching cache ids (string)
475     */
476    public function getIdsMatchingTags($tags = array())
477    {
478        if (!$this->_extendedBackend) {
479            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
480        }
481        if (!($this->_backendCapabilities['tags'])) {
482            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
483        }
484
485        $ids = $this->_backend->getIdsMatchingTags($tags);
486
487        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
488        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
489            $prefix    = & $this->_options['cache_id_prefix'];
490            $prefixLen = strlen($prefix);
491            foreach ($ids as &$id) {
492                if (strpos($id, $prefix) === 0) {
493                    $id = substr($id, $prefixLen);
494                }
495            }
496        }
497
498        return $ids;
499    }
500
501    /**
502     * Return an array of stored cache ids which don't match given tags
503     *
504     * In case of multiple tags, a logical OR is made between tags
505     *
506     * @param array $tags array of tags
507     * @return array array of not matching cache ids (string)
508     */
509    public function getIdsNotMatchingTags($tags = array())
510    {
511        if (!$this->_extendedBackend) {
512            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
513        }
514        if (!($this->_backendCapabilities['tags'])) {
515            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
516        }
517
518        $ids = $this->_backend->getIdsNotMatchingTags($tags);
519
520        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
521        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
522            $prefix    = & $this->_options['cache_id_prefix'];
523            $prefixLen = strlen($prefix);
524            foreach ($ids as &$id) {
525                if (strpos($id, $prefix) === 0) {
526                    $id = substr($id, $prefixLen);
527                }
528            }
529        }
530
531        return $ids;
532    }
533
534    /**
535     * Return an array of stored cache ids which match any given tags
536     *
537     * In case of multiple tags, a logical OR is made between tags
538     *
539     * @param array $tags array of tags
540     * @return array array of matching any cache ids (string)
541     */
542    public function getIdsMatchingAnyTags($tags = array())
543    {
544        if (!$this->_extendedBackend) {
545            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
546        }
547        if (!($this->_backendCapabilities['tags'])) {
548            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
549        }
550
551        $ids = $this->_backend->getIdsMatchingAnyTags($tags);
552
553        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
554        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
555            $prefix    = & $this->_options['cache_id_prefix'];
556            $prefixLen = strlen($prefix);
557            foreach ($ids as &$id) {
558                if (strpos($id, $prefix) === 0) {
559                    $id = substr($id, $prefixLen);
560                }
561            }
562        }
563
564        return $ids;
565    }
566
567    /**
568     * Return an array of stored cache ids
569     *
570     * @return array array of stored cache ids (string)
571     */
572    public function getIds()
573    {
574        if (!$this->_extendedBackend) {
575            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
576        }
577
578        $ids = $this->_backend->getIds();
579
580        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
581        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
582            $prefix    = & $this->_options['cache_id_prefix'];
583            $prefixLen = strlen($prefix);
584            foreach ($ids as &$id) {
585                if (strpos($id, $prefix) === 0) {
586                    $id = substr($id, $prefixLen);
587                }
588            }
589        }
590
591        return $ids;
592    }
593
594    /**
595     * Return an array of stored tags
596     *
597     * @return array array of stored tags (string)
598     */
599    public function getTags()
600    {
601        if (!$this->_extendedBackend) {
602            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
603        }
604        if (!($this->_backendCapabilities['tags'])) {
605            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
606        }
607        return $this->_backend->getTags();
608    }
609
610    /**
611     * Return the filling percentage of the backend storage
612     *
613     * @return int integer between 0 and 100
614     */
615    public function getFillingPercentage()
616    {
617        if (!$this->_extendedBackend) {
618            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
619        }
620        return $this->_backend->getFillingPercentage();
621    }
622
623    /**
624     * Return an array of metadatas for the given cache id
625     *
626     * The array will include these keys :
627     * - expire : the expire timestamp
628     * - tags : a string array of tags
629     * - mtime : timestamp of last modification time
630     *
631     * @param string $id cache id
632     * @return array array of metadatas (false if the cache id is not found)
633     */
634    public function getMetadatas($id)
635    {
636        if (!$this->_extendedBackend) {
637            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
638        }
639        $id = $this->_id($id); // cache id may need prefix
640        return $this->_backend->getMetadatas($id);
641    }
642
643    /**
644     * Give (if possible) an extra lifetime to the given cache id
645     *
646     * @param string $id cache id
647     * @param int $extraLifetime
648     * @return boolean true if ok
649     */
650    public function touch($id, $extraLifetime)
651    {
652        if (!$this->_extendedBackend) {
653            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
654        }
655        $id = $this->_id($id); // cache id may need prefix
656
657        $this->_log("Zend_Cache_Core: touch item '{$id}'", 7);
658        return $this->_backend->touch($id, $extraLifetime);
659    }
660
661    /**
662     * Validate a cache id or a tag (security, reliable filenames, reserved prefixes...)
663     *
664     * Throw an exception if a problem is found
665     *
666     * @param  string $string Cache id or tag
667     * @throws Zend_Cache_Exception
668     * @return void
669     */
670    protected static function _validateIdOrTag($string)
671    {
672        if (!is_string($string)) {
673            Zend_Cache::throwException('Invalid id or tag : must be a string');
674        }
675        if (substr($string, 0, 9) == 'internal-') {
676            Zend_Cache::throwException('"internal-*" ids or tags are reserved');
677        }
678        if (!preg_match('~^[a-zA-Z0-9_]+$~D', $string)) {
679            Zend_Cache::throwException("Invalid id or tag '$string' : must use only [a-zA-Z0-9_]");
680        }
681    }
682
683    /**
684     * Validate a tags array (security, reliable filenames, reserved prefixes...)
685     *
686     * Throw an exception if a problem is found
687     *
688     * @param  array $tags Array of tags
689     * @throws Zend_Cache_Exception
690     * @return void
691     */
692    protected static function _validateTagsArray($tags)
693    {
694        if (!is_array($tags)) {
695            Zend_Cache::throwException('Invalid tags array : must be an array');
696        }
697        foreach($tags as $tag) {
698            self::_validateIdOrTag($tag);
699        }
700        reset($tags);
701    }
702
703    /**
704     * Make sure if we enable logging that the Zend_Log class
705     * is available.
706     * Create a default log object if none is set.
707     *
708     * @throws Zend_Cache_Exception
709     * @return void
710     */
711    protected function _loggerSanity()
712    {
713        if (!isset($this->_options['logging']) || !$this->_options['logging']) {
714            return;
715        }
716
717        if (isset($this->_options['logger']) && $this->_options['logger'] instanceof Zend_Log) {
718            return;
719        }
720
721        // Create a default logger to the standard output stream
722        require_once 'Zend/Log.php';
723        require_once 'Zend/Log/Writer/Stream.php';
724        require_once 'Zend/Log/Filter/Priority.php';
725        $logger = new Zend_Log(new Zend_Log_Writer_Stream('php://output'));
726        $logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::WARN, '<='));
727        $this->_options['logger'] = $logger;
728    }
729
730    /**
731     * Log a message at the WARN (4) priority.
732     *
733     * @param string $message
734     * @throws Zend_Cache_Exception
735     * @return void
736     */
737    protected function _log($message, $priority = 4)
738    {
739        if (!$this->_options['logging']) {
740            return;
741        }
742        if (!(isset($this->_options['logger']) || $this->_options['logger'] instanceof Zend_Log)) {
743            Zend_Cache::throwException('Logging is enabled but logger is not set');
744        }
745        $logger = $this->_options['logger'];
746        $logger->log($message, $priority);
747    }
748
749    /**
750     * Make and return a cache id
751     *
752     * Checks 'cache_id_prefix' and returns new id with prefix or simply the id if null
753     *
754     * @param  string $id Cache id
755     * @return string Cache id (with or without prefix)
756     */
757    protected function _id($id)
758    {
759        if (($id !== null) && isset($this->_options['cache_id_prefix'])) {
760            return $this->_options['cache_id_prefix'] . $id; // return with prefix
761        }
762        return $id; // no prefix, just return the $id passed
763    }
764
765}