1. sfViewCacheManager.class.php
  2. /**
 * Cache class to cache the HTML results for actions and templates.
 *
 * This class uses a sfCache instance implementation to store cache.
 *
 * To disable all caching, you can set the [sf_cache] constant to false.
 *
 * @package    symfony
 * @subpackage view
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfViewCacheManager.class.php 24615 2009-11-30 22:30:46Z Kris.Wallsmith $
 */
  3. class sfViewCacheManager
  4. {
  5.   protected
  6.     $cache       = null,
  7.     $cacheConfig = array(),
  8.     $context     = null,
  9.     $dispatcher  = null,
  10.     $controller  = null,
  11.     $routing     = null,
  12.     $request     = null,
  13.     $loaded      = array();
  15.   /**
  16.    * Class constructor.
  17.    *
  18.    * @see initialize()
  19.    */
  20.   public function __construct($context, sfCache $cache, $options = array())
  21.   {
  22.     $this->initialize($context, $cache, $options);
  23.   }
  25.   /**
  26.    * Initializes the cache manager.
  27.    *
  28.    * @param sfContext $context  Current application context
  29.    * @param sfCache   $cache    An sfCache instance
  30.    */
  31.   public function initialize($context, sfCache $cache, $options = array())
  32.   {
  33.     $this->context    = $context;
  34.     $this->dispatcher = $context->getEventDispatcher();
  35.     $this->controller = $context->getController();
  36.     $this->request    = $context->getRequest();
  37.     $this->options    = array_merge(array(
  38.         'cache_key_use_vary_headers' => true,
  39.         'cache_key_use_host_name'    => true,
  40.       ), $options);
  42.     if (sfConfig::get('sf_web_debug'))
  43.     {
  44.       $this->dispatcher->connect('view.cache.filter_content', array($this, 'decorateContentWithDebug'));
  45.     }
  47.     // empty configuration
  48.     $this->cacheConfig = array();
  50.     // cache instance
  51.     $this->cache = $cache;
  53.     // routing instance
  54.     $this->routing = $context->getRouting();
  55.   }
  57.   /**
  58.    * Retrieves the current cache context.
  59.    *
  60.    * @return sfContext The sfContext instance
  61.    */
  62.   public function getContext()
  63.   {
  64.     return $this->context;
  65.   }
  67.   /**
  68.    * Retrieves the current cache object.
  69.    *
  70.    * @return sfCache The current cache object
  71.    */
  72.   public function getCache()
  73.   {
  74.     return $this->cache;
  75.   }
  77.   /**
  78.    * Generates a unique cache key for an internal URI.
  79.    * This cache key can be used by any of the cache engines as a unique identifier to a cached resource
  80.    *
  81.    * Basically, the cache key generated for the following internal URI:
  82.    *   module/action?key1=value1&key2=value2
  83.    * Looks like:
  84.    *   /localhost/all/module/action/key1/value1/key2/value2
  85.    *
  86.    * @param  string $internalUri       The internal unified resource identifier
  87.    *                                   Accepts rules formatted like 'module/action?key1=value1&key2=value2'
  88.    *                                   Does not accept rules starting with a route name, except for '@sf_cache_partial'
  89.    * @param  string $hostName          The host name
  90.    *                                   Optional - defaults to the current host name bu default
  91.    * @param  string $vary              The vary headers, separated by |, or "all" for all vary headers
  92.    *                                   Defaults to 'all'
  93.    * @param  string $contextualPrefix  The contextual prefix for contextual partials.
  94.    *                                   Defaults to 'currentModule/currentAction/currentPAram1/currentvalue1'
  95.    *                                   Used only by the sfViewCacheManager::remove() method
  96.    *
  97.    * @return string The cache key
  98.    *                If some of the parameters contained wildcards (* or **), the generated key will also have wildcards
  99.    */
  100.   public function generateCacheKey($internalUri, $hostName = '', $vary = '', $contextualPrefix = '')
  101.   {
  102.     if ($callable = sfConfig::get('sf_cache_namespace_callable'))
  103.     {
  104.       if (!is_callable($callable))
  105.       {
  106.         throw new sfException(sprintf('"%s" cannot be called as a function.', var_export($callable, true)));
  107.       }
  109.       return call_user_func($callable, $internalUri, $hostName, $vary, $contextualPrefix, $this);
  110.     }
  112.     if (strpos($internalUri, '@') === 0 && strpos($internalUri, '@sf_cache_partial') === false)
  113.     {
  114.       throw new sfException('A cache key cannot be generated for an internal URI using the @rule syntax');
  115.     }
  117.     $cacheKey = '';
  119.     if ($this->isContextual($internalUri))
  120.     {
  121.       // Contextual partial
  122.       if (!$contextualPrefix)
  123.       {
  124.         list($route_name, $params) = $this->controller->convertUrlStringToParameters($this->routing->getCurrentInternalUri());
  125.         $cacheKey = $this->convertParametersToKey($params);
  126.       }
  127.       else
  128.       {
  129.         $cacheKey = $contextualPrefix;
  130.       }
  131.       list($route_name, $params) = $this->controller->convertUrlStringToParameters($internalUri);
  132.       $cacheKey .= sprintf('/%s/%s/%s', $params['module'], $params['action'], isset($params['sf_cache_key']) ? $params['sf_cache_key'] : '');
  133.     }
  134.     else
  135.     {
  136.       // Regular action or non-contextual partial
  137.       list($route_name, $params) = $this->controller->convertUrlStringToParameters($internalUri);
  138.       if ($route_name == 'sf_cache_partial')
  139.       {
  140.         $cacheKey = 'sf_cache_partial/';
  141.       }
  143.       $cacheKey .= $this->convertParametersToKey($params);
  144.     }
  146.     $cacheKey = sprintf('/%s/%s/%s', $this->getCacheKeyHostNamePart($hostName), $this->getCacheKeyVaryHeaderPart($internalUri, $vary), $cacheKey);
  148.     // replace multiple /
  149.     $cacheKey = preg_replace('#/+#', '/', $cacheKey);
  151.     return $cacheKey;
  152.   }
  154.   /**
  155.    * Gets the vary header part of view cache key.
  156.    *
  157.    * @param  string $vary
  158.    * @return string
  159.    */
  160.   protected function getCacheKeyVaryHeaderPart($internalUri, $vary = '')
  161.   {
  162.     if (!$this->options['cache_key_use_vary_headers'])
  163.     {
  164.       return '';
  165.     }
  167.     // prefix with vary headers
  168.     if (!$vary)
  169.     {
  170.       $varyHeaders = $this->getVary($internalUri);
  172.       if (!$varyHeaders)
  173.       {
  174.         return 'all';
  175.       }
  177.       sort($varyHeaders);
  178.       $request = $this->context->getRequest();
  179.       $varys = array();
  181.       foreach ($varyHeaders as $header)
  182.       {
  183.         $varys[] = $header . '-' . preg_replace('/\W+/', '_', $request->getHttpHeader($header));
  184.       }
  185.       $vary = implode($varys, '-');
  186.     }
  188.     return $vary;
  189.   }
  191.   /**
  192.    * Gets the hostname part of view cache key.
  193.    *
  194.    * @param string $hostName
  195.    * @return void
  196.    */
  197.   protected function getCacheKeyHostNamePart($hostName = '')
  198.   {
  199.     if (!$this->options['cache_key_use_host_name'])
  200.     {
  201.       return '';
  202.     }
  204.     if (!$hostName)
  205.     {
  206.       $hostName = $this->context->getRequest()->getHost();
  207.     }
  209.     $hostName = preg_replace('/[^a-z0-9\*]/i', '_', $hostName);
  210.     $hostName = preg_replace('/_+/', '_', $hostName);
  212.     return strtolower($hostName);
  213.   }
  215.   /**
  216.    * Transforms an associative array of parameters from an URI into a unique key
  217.    *
  218.    * @param  array $params  Associative array of parameters from the URI (including, at least, module and action)
  219.    *
  220.    * @return string Unique key
  221.    */
  222.   protected function convertParametersToKey($params)
  223.   {
  224.     if(!isset($params['module']) || !isset($params['action']))
  225.     {
  226.       throw new sfException('A cache key must contain both a module and an action parameter');
  227.     }
  228.     $module = $params['module'];
  229.     unset($params['module']);
  230.     $action = $params['action'];
  231.     unset($params['action']);
  232.     ksort($params);
  233.     $cacheKey = sprintf('%s/%s', $module, $action);
  234.     foreach ($params as $key => $value)
  235.     {
  236.       $cacheKey .= sprintf('/%s/%s', $key, $value);
  237.     }
  239.     return $cacheKey;
  240.   }
  242.   /**
  243.    * Adds a cache to the manager.
  244.    *
  245.    * @param string $moduleName  Module name
  246.    * @param string $actionName  Action name
  247.    * @param array  $options     Options for the cache
  248.    */
  249.   public function addCache($moduleName, $actionName, $options = array())
  250.   {
  251.     // normalize vary headers
  252.     if (isset($options['vary']))
  253.     {
  254.       foreach ($options['vary'] as $key => $name)
  255.       {
  256.         $options['vary'][$key] = strtr(strtolower($name), '_', '-');
  257.       }
  258.     }
  260.     $options['lifeTime'] = isset($options['lifeTime']) ? $options['lifeTime'] : 0;
  261.     if (!isset($this->cacheConfig[$moduleName]))
  262.     {
  263.       $this->cacheConfig[$moduleName] = array();
  264.     }
  265.     $this->cacheConfig[$moduleName][$actionName] = array(
  266.       'withLayout'     => isset($options['withLayout']) ? $options['withLayout'] : false,
  267.       'lifeTime'       => $options['lifeTime'],
  268.       'clientLifeTime' => isset($options['clientLifeTime']) ? $options['clientLifeTime'] : $options['lifeTime'],
  269.       'contextual'     => isset($options['contextual']) ? $options['contextual'] : false,
  270.       'vary'           => isset($options['vary']) ? $options['vary'] : array(),
  271.     );
  272.   }
  274.   /**
  275.    * Registers configuration options for the cache.
  276.    *
  277.    * @param string $moduleName  Module name
  278.    */
  279.   public function registerConfiguration($moduleName)
  280.   {
  281.     if (!isset($this->loaded[$moduleName]))
  282.     {
  283.       require($this->context->getConfigCache()->checkConfig('modules/'.$moduleName.'/config/cache.yml'));
  284.       $this->loaded[$moduleName] = true;
  285.     }
  286.   }
  288.   /**
  289.    * Retrieves the layout from the cache option list.
  290.    *
  291.    * @param  string $internalUri  Internal uniform resource identifier
  292.    *
  293.    * @return bool true, if have layout otherwise false
  294.    */
  295.   public function withLayout($internalUri)
  296.   {
  297.     return $this->getCacheConfig($internalUri, 'withLayout', false);
  298.   }
  300.   /**
  301.    * Retrieves lifetime from the cache option list.
  302.    *
  303.    * @param  string $internalUri  Internal uniform resource identifier
  304.    *
  305.    * @return int LifeTime
  306.    */
  307.   public function getLifeTime($internalUri)
  308.   {
  309.     return $this->getCacheConfig($internalUri, 'lifeTime', 0);
  310.   }
  312.   /**
  313.    * Retrieves client lifetime from the cache option list
  314.    *
  315.    * @param  string $internalUri  Internal uniform resource identifier
  316.    *
  317.    * @return int Client lifetime
  318.    */
  319.   public function getClientLifeTime($internalUri)
  320.   {
  321.     return $this->getCacheConfig($internalUri, 'clientLifeTime', 0);
  322.   }
  324.   /**
  325.    * Retrieves contextual option from the cache option list.
  326.    *
  327.    * @param  string $internalUri  Internal uniform resource identifier
  328.    *
  329.    * @return boolean true, if is contextual otherwise false
  330.    */
  331.   public function isContextual($internalUri)
  332.   {
  333.     return $this->getCacheConfig($internalUri, 'contextual', false);
  334.   }
  336.   /**
  337.    * Retrieves vary option from the cache option list.
  338.    *
  339.    * @param  string $internalUri  Internal uniform resource identifier
  340.    *
  341.    * @return array Vary options for the cache
  342.    */
  343.   public function getVary($internalUri)
  344.   {
  345.     return $this->getCacheConfig($internalUri, 'vary', array());
  346.   }
  348.   /**
  349.    * Gets a config option from the cache.
  350.    *
  351.    * @param string $internalUri   Internal uniform resource identifier
  352.    * @param string $key           Option name
  353.    * @param string $defaultValue  Default value of the option
  354.    *
  355.    * @return mixed Value of the option
  356.    */
  357.   protected function getCacheConfig($internalUri, $key, $defaultValue = null)
  358.   {
  359.     list($route_name, $params) = $this->controller->convertUrlStringToParameters($internalUri);
  361.     $this->registerConfiguration($params['module']);
  363.     $value = $defaultValue;
  364.     if (isset($this->cacheConfig[$params['module']][$params['action']][$key]))
  365.     {
  366.       $value = $this->cacheConfig[$params['module']][$params['action']][$key];
  367.     }
  368.     else if (isset($this->cacheConfig[$params['module']]['DEFAULT'][$key]))
  369.     {
  370.       $value = $this->cacheConfig[$params['module']]['DEFAULT'][$key];
  371.     }
  373.     return $value;
  374.   }
  376.   /**
  377.    * Returns true if the current content is cacheable.
  378.    *
  379.    * Possible break in backward compatibility: If the sf_lazy_cache_key
  380.    * setting is turned on in settings.yml, this method is not used when
  381.    * initially checking a partial's cacheability.
  382.    *
  383.    * @see sfPartialView, isActionCacheable()
  384.    *
  385.    * @param  string $internalUri  Internal uniform resource identifier
  386.    *
  387.    * @return bool true, if the content is cacheable otherwise false
  388.    */
  389.   public function isCacheable($internalUri)
  390.   {
  391.     if ($this->request instanceof sfWebRequest && !$this->request->isMethod(sfRequest::GET))
  392.     {
  393.       return false;
  394.     }
  396.     list($route_name, $params) = $this->controller->convertUrlStringToParameters($internalUri);
  398.     $this->registerConfiguration($params['module']);
  400.     if (isset($this->cacheConfig[$params['module']][$params['action']]))
  401.     {
  402.       return ($this->cacheConfig[$params['module']][$params['action']]['lifeTime'] > 0);
  403.     }
  404.     else if (isset($this->cacheConfig[$params['module']]['DEFAULT']))
  405.     {
  406.       return ($this->cacheConfig[$params['module']]['DEFAULT']['lifeTime'] > 0);
  407.     }
  409.     return false;
  410.   }
  412.   /**
  413.    * Returns true if the action is cacheable.
  414.    *
  415.    * @param  string $moduleName A module name
  416.    * @param  string $actionName An action or partial template name
  417.    *
  418.    * @return boolean True if the action is cacheable
  419.    *
  420.    * @see isCacheable()
  421.    */
  422.   public function isActionCacheable($moduleName, $actionName)
  423.   {
  424.     if ($this->request instanceof sfWebRequest && !$this->request->isMethod(sfRequest::GET))
  425.     {
  426.       return false;
  427.     }
  429.     $this->registerConfiguration($moduleName);
  431.     if (isset($this->cacheConfig[$moduleName][$actionName]))
  432.     {
  433.       return $this->cacheConfig[$moduleName][$actionName]['lifeTime'] > 0;
  434.     }
  435.     else if (isset($this->cacheConfig[$moduleName]['DEFAULT']))
  436.     {
  437.       return $this->cacheConfig[$moduleName]['DEFAULT']['lifeTime'] > 0;
  438.     }
  440.     return false;
  441.   }
  443.   /**
  444.    * Retrieves content in the cache.
  445.    *
  446.    * @param  string $internalUri  Internal uniform resource identifier
  447.    *
  448.    * @return string The content in the cache
  449.    */
  450.   public function get($internalUri)
  451.   {
  452.     // no cache or no cache set for this action
  453.     if (!$this->isCacheable($internalUri) || $this->ignore())
  454.     {
  455.       return null;
  456.     }
  458.     $retval = $this->cache->get($this->generateCacheKey($internalUri));
  460.     if (sfConfig::get('sf_logging_enabled'))
  461.     {
  462.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Cache for "%s" %s', $internalUri, $retval !== null ? 'exists' : 'does not exist'))));
  463.     }
  465.     return $retval;
  466.   }
  468.   /**
  469.    * Returns true if there is a cache.
  470.    *
  471.    * @param  string $internalUri  Internal uniform resource identifier
  472.    *
  473.    * @return bool true, if there is a cache otherwise false
  474.    */
  475.   public function has($internalUri)
  476.   {
  477.     if (!$this->isCacheable($internalUri) || $this->ignore())
  478.     {
  479.       return null;
  480.     }
  482.     return $this->cache->has($this->generateCacheKey($internalUri));
  483.   }
  485.   /**
  486.    * Ignores the cache functionality.
  487.    *
  488.    * @return bool true, if the cache is ignore otherwise false
  489.    */
  490.   protected function ignore()
  491.   {
  492.     // ignore cache parameter? (only available in debug mode)
  493.     if (sfConfig::get('sf_debug') && $this->context->getRequest()->getAttribute('sf_ignore_cache'))
  494.     {
  495.       if (sfConfig::get('sf_logging_enabled'))
  496.       {
  497.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array('Discard cache')));
  498.       }
  500.       return true;
  501.     }
  503.     return false;
  504.   }
  506.   /**
  507.    * Sets the cache content.
  508.    *
  509.    * @param  string $data         Data to put in the cache
  510.    * @param  string $internalUri  Internal uniform resource identifier
  511.    *
  512.    * @return boolean true, if the data get set successfully otherwise false
  513.    */
  514.   public function set($data, $internalUri)
  515.   {
  516.     if (!$this->isCacheable($internalUri))
  517.     {
  518.       return false;
  519.     }
  521.     try
  522.     {
  523.       $ret = $this->cache->set($this->generateCacheKey($internalUri), $data, $this->getLifeTime($internalUri));
  524.     }
  525.     catch (Exception $e)
  526.     {
  527.       return false;
  528.     }
  530.     if (sfConfig::get('sf_logging_enabled'))
  531.     {
  532.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Save cache for "%s"', $internalUri))));
  533.     }
  535.     return true;
  536.   }
  538.   /**
  539.    * Removes the content in the cache.
  540.    *
  541.    * @param  string $internalUri       Internal uniform resource identifier
  542.    * @param  string $hostName          The host name
  543.    * @param  string $vary              The vary headers, separated by |, or "all" for all vary headers
  544.    * @param  string $contextualPrefix  The removal prefix for contextual partials. Defaults to '**' (all actions, all params)
  545.    *
  546.    * @return bool true, if the remove happened, false otherwise
  547.    */
  548.   public function remove($internalUri, $hostName = '', $vary = '', $contextualPrefix = '**')
  549.   {
  550.     if (sfConfig::get('sf_logging_enabled'))
  551.     {
  552.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Remove cache for "%s"', $internalUri))));
  553.     }
  555.     $cacheKey = $this->generateCacheKey($internalUri, $hostName, $vary, $contextualPrefix);
  557.     if(strpos($cacheKey, '*'))
  558.     {
  559.       return $this->cache->removePattern($cacheKey);
  560.     }
  561.     elseif ($this->cache->has($cacheKey))
  562.     {
  563.       return $this->cache->remove($cacheKey);
  564.     }
  565.   }
  567.   /**
  568.    * Retrieves the last modified time.
  569.    *
  570.    * @param  string $internalUri  Internal uniform resource identifier
  571.    *
  572.    * @return int    The last modified datetime
  573.    */
  574.   public function getLastModified($internalUri)
  575.   {
  576.     if (!$this->isCacheable($internalUri))
  577.     {
  578.       return 0;
  579.     }
  581.     return $this->cache->getLastModified($this->generateCacheKey($internalUri));
  582.   }
  584.   /**
  585.    * Retrieves the timeout.
  586.    *
  587.    * @param  string $internalUri  Internal uniform resource identifier
  588.    *
  589.    * @return int    The timeout datetime
  590.    */
  591.   public function getTimeout($internalUri)
  592.   {
  593.     if (!$this->isCacheable($internalUri))
  594.     {
  595.       return 0;
  596.     }
  598.     return $this->cache->getTimeout($this->generateCacheKey($internalUri));
  599.   }
  601.   /**
  602.    * Starts the fragment cache.
  603.    *
  604.    * @param  string $name            Unique fragment name
  605.    * @param  string $lifeTime        Life time for the cache
  606.    * @param  string $clientLifeTime  Client life time for the cache
  607.    * @param  array  $vary            Vary options for the cache
  608.    *
  609.    * @return bool true, if success otherwise false
  610.    */
  611.   public function start($name, $lifeTime, $clientLifeTime = null, $vary = array())
  612.   {
  613.     $internalUri = $this->routing->getCurrentInternalUri();
  615.     if (!$clientLifeTime)
  616.     {
  617.       $clientLifeTime = $lifeTime;
  618.     }
  620.     // add cache config to cache manager
  621.     list($route_name, $params) = $this->controller->convertUrlStringToParameters($internalUri);
  622.     $this->addCache($params['module'], $params['action'], array('withLayout' => false, 'lifeTime' => $lifeTime, 'clientLifeTime' => $clientLifeTime, 'vary' => $vary));
  624.     // get data from cache if available
  625.     $data = $this->get($internalUri.(strpos($internalUri, '?') ? '&' : '?').'_sf_cache_key='.$name);
  626.     if ($data !== null)
  627.     {
  628.       return $data;
  629.     }
  630.     else
  631.     {
  632.       ob_start();
  633.       ob_implicit_flush(0);
  635.       return null;
  636.     }
  637.   }
  639.   /**
  640.    * Stops the fragment cache.
  641.    *
  642.    * @param  string $name Unique fragment name
  643.    *
  644.    * @return bool true, if success otherwise false
  645.    */
  646.   public function stop($name)
  647.   {
  648.     $data = ob_get_clean();
  650.     // save content to cache
  651.     $internalUri = $this->routing->getCurrentInternalUri();
  652.     try
  653.     {
  654.       $this->set($data, $internalUri.(strpos($internalUri, '?') ? '&' : '?').'_sf_cache_key='.$name);
  655.     }
  656.     catch (Exception $e)
  657.     {
  658.     }
  660.     return $data;
  661.   }
  663.   /**
  664.    * Computes the cache key based on the passed parameters.
  665.    *
  666.    * @param array $parameters  An array of parameters
  667.    */
  668.   public function computeCacheKey(array $parameters)
  669.   {
  670.     if (isset($parameters['sf_cache_key']))
  671.     {
  672.       return $parameters['sf_cache_key'];
  673.     }
  675.     if (sfConfig::get('sf_logging_enabled'))
  676.     {
  677.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array('Generate cache key')));
  678.     }
  680.     return md5(serialize($parameters));
  681.   }
  683.   /**
  684.    * Checks that the supplied parameters include a cache key.
  685.    *
  686.    * If no 'sf_cache_key' parameter is present one is added to the array as
  687.    * it is passed by reference.
  688.    *
  689.    * @param  array  $parameters An array of parameters
  690.    *
  691.    * @return string The cache key
  692.    */
  693.   public function checkCacheKey(array & $parameters)
  694.   {
  695.     $parameters['sf_cache_key'] = $this->computeCacheKey($parameters);
  697.     return $parameters['sf_cache_key'];
  698.   }
  700.   /**
  701.    * Computes a partial internal URI.
  702.    *
  703.    * @param  string $module    The module name
  704.    * @param  string $action    The action name
  705.    * @param  string $cacheKey  The cache key
  706.    *
  707.    * @return string The internal URI
  708.    */
  709.   public function getPartialUri($module, $action, $cacheKey)
  710.   {
  711.     return sprintf('@sf_cache_partial?module=%s&action=%s&sf_cache_key=%s', $module, $action, $cacheKey);
  712.   }
  714.   /**
  715.    * Returns whether a partial template is in the cache.
  716.    *
  717.    * @param  string $module    The module name
  718.    * @param  string $action    The action name
  719.    * @param  string $cacheKey  The cache key
  720.    *
  721.    * @return bool true if a partial is in the cache, false otherwise
  722.    */
  723.   public function hasPartialCache($module, $action, $cacheKey)
  724.   {
  725.     return $this->has($this->getPartialUri($module, $action, $cacheKey));
  726.   }
  728.   /**
  729.    * Gets a partial template from the cache.
  730.    *
  731.    * @param  string $module    The module name
  732.    * @param  string $action    The action name
  733.    * @param  string $cacheKey  The cache key
  734.    *
  735.    * @return string The cache content
  736.    */
  737.   public function getPartialCache($module, $action, $cacheKey)
  738.   {
  739.     $uri = $this->getPartialUri($module, $action, $cacheKey);
  741.     if (!$this->isCacheable($uri))
  742.     {
  743.       return null;
  744.     }
  746.     // retrieve content from cache
  747.     $cache = $this->get($uri);
  749.     if (null === $cache)
  750.     {
  751.       return null;
  752.     }
  754.     $cache = unserialize($cache);
  755.     $content = $cache['content'];
  756.     $this->context->getResponse()->merge($cache['response']);
  758.     if (sfConfig::get('sf_web_debug'))
  759.     {
  760.       $content = $this->dispatcher->filter(new sfEvent($this, 'view.cache.filter_content', array('response' => $this->context->getResponse(), 'uri' => $uri, 'new' => false)), $content)->getReturnValue();
  761.     }
  763.     return $content;
  764.   }
  766.   /**
  767.    * Sets an action template in the cache.
  768.    *
  769.    * @param  string $module    The module name
  770.    * @param  string $action    The action name
  771.    * @param  string $cacheKey  The cache key
  772.    * @param  string $content   The content to cache
  773.    *
  774.    * @return string The cached content
  775.    */
  776.   public function setPartialCache($module, $action, $cacheKey, $content)
  777.   {
  778.     $uri = $this->getPartialUri($module, $action, $cacheKey);
  779.     if (!$this->isCacheable($uri))
  780.     {
  781.       return $content;
  782.     }
  784.     $saved = $this->set(serialize(array('content' => $content, 'response' => $this->context->getResponse())), $uri);
  786.     if ($saved && sfConfig::get('sf_web_debug'))
  787.     {
  788.       $content = $this->dispatcher->filter(new sfEvent($this, 'view.cache.filter_content', array('response' => $this->context->getResponse(), 'uri' => $uri, 'new' => true)), $content)->getReturnValue();
  789.     }
  791.     return $content;
  792.   }
  794.   /**
  795.    * Returns whether an action template is in the cache.
  796.    *
  797.    * @param  string  $uri  The internal URI
  798.    *
  799.    * @return bool true if an action is in the cache, false otherwise
  800.    */
  801.   public function hasActionCache($uri)
  802.   {
  803.     return $this->has($uri) && !$this->withLayout($uri);
  804.   }
  806.   /**
  807.    * Gets an action template from the cache.
  808.    *
  809.    * @param  string $uri  The internal URI
  810.    *
  811.    * @return array  An array composed of the cached content and the view attribute holder
  812.    */
  813.   public function getActionCache($uri)
  814.   {
  815.     if (!$this->isCacheable($uri) || $this->withLayout($uri))
  816.     {
  817.       return null;
  818.     }
  820.     // retrieve content from cache
  821.     $cache = $this->get($uri);
  823.     if (null === $cache)
  824.     {
  825.       return null;
  826.     }
  828.     $cache = unserialize($cache);
  829.     $content = $cache['content'];
  830.     $cache['response']->setEventDispatcher($this->dispatcher);
  831.     $this->context->getResponse()->copyProperties($cache['response']);
  833.     if (sfConfig::get('sf_web_debug'))
  834.     {
  835.       $content = $this->dispatcher->filter(new sfEvent($this, 'view.cache.filter_content', array('response' => $this->context->getResponse(), 'uri' => $uri, 'new' => false)), $content)->getReturnValue();
  836.     }
  838.     return array($content, $cache['decoratorTemplate']);
  839.   }
  841.   /**
  842.    * Sets an action template in the cache.
  843.    *
  844.    * @param  string $uri                The internal URI
  845.    * @param  string $content            The content to cache
  846.    * @param  string $decoratorTemplate  The view attribute holder to cache
  847.    *
  848.    * @return string The cached content
  849.    */
  850.   public function setActionCache($uri, $content, $decoratorTemplate)
  851.   {
  852.     if (!$this->isCacheable($uri) || $this->withLayout($uri))
  853.     {
  854.       return $content;
  855.     }
  857.     $saved = $this->set(serialize(array('content' => $content, 'decoratorTemplate' => $decoratorTemplate, 'response' => $this->context->getResponse())), $uri);
  859.     if ($saved && sfConfig::get('sf_web_debug'))
  860.     {
  861.       $content = $this->dispatcher->filter(new sfEvent($this, 'view.cache.filter_content', array('response' => $this->context->getResponse(), 'uri' => $uri, 'new' => true)), $content)->getReturnValue();
  862.     }
  864.     return $content;
  865.   }
  867.   /**
  868.    * Sets a page in the cache.
  869.    *
  870.    * @param string $uri  The internal URI
  871.    */
  872.   public function setPageCache($uri)
  873.   {
  874.     if (sfView::RENDER_CLIENT != $this->controller->getRenderMode())
  875.     {
  876.       return;
  877.     }
  879.     // save content in cache
  880.     $saved = $this->set(serialize($this->context->getResponse()), $uri);
  882.     if ($saved && sfConfig::get('sf_web_debug'))
  883.     {
  884.       $content = $this->dispatcher->filter(new sfEvent($this, 'view.cache.filter_content', array('response' => $this->context->getResponse(), 'uri' => $uri, 'new' => true)), $this->context->getResponse()->getContent())->getReturnValue();
  886.       $this->context->getResponse()->setContent($content);
  887.     }
  888.   }
  890.   /**
  891.    * Gets a page from the cache.
  892.    *
  893.    * @param  string $uri  The internal URI
  894.    *
  895.    * @return string The cached page
  896.    */
  897.   public function getPageCache($uri)
  898.   {
  899.     $retval = $this->get($uri);
  901.     if (null === $retval)
  902.     {
  903.       return false;
  904.     }
  906.     $cachedResponse = unserialize($retval);
  907.     $cachedResponse->setEventDispatcher($this->dispatcher);
  909.     if (sfView::RENDER_VAR == $this->controller->getRenderMode())
  910.     {
  911.       $this->controller->getActionStack()->getLastEntry()->setPresentation($cachedResponse->getContent());
  912.       $this->context->getResponse()->setContent('');
  913.     }
  914.     else
  915.     {
  916.       $this->context->setResponse($cachedResponse);
  918.       if (sfConfig::get('sf_web_debug'))
  919.       {
  920.         $content = $this->dispatcher->filter(new sfEvent($this, 'view.cache.filter_content', array('response' => $this->context->getResponse(), 'uri' => $uri, 'new' => false)), $this->context->getResponse()->getContent())->getReturnValue();
  922.         $this->context->getResponse()->setContent($content);
  923.       }
  924.     }
  926.     return true;
  927.   }
  929.   /**
  930.    * Returns the current request's cache key.
  931.    *
  932.    * This cache key is calculated based on the routing factory's current URI
  933.    * and any GET parameters from the current request factory.
  934.    *
  935.    * @return string The cache key for the current request
  936.    */
  937.   public function getCurrentCacheKey()
  938.   {
  939.     $cacheKey = $this->routing->getCurrentInternalUri();
  941.     if ($getParameters = $this->request->getGetParameters())
  942.     {
  943.       $cacheKey .= false === strpos($cacheKey, '?') ? '?' : '&';
  944.       $cacheKey .= http_build_query($getParameters, null, '&');
  945.     }
  947.     return $cacheKey;
  948.   }
  950.   /**
  951.    * Listens to the 'view.cache.filter_content' event to decorate a chunk of HTML with cache information.
  952.    *
  953.    * @param sfEvent $event   A sfEvent instance
  954.    * @param string  $content The HTML content
  955.    *
  956.    * @return string The decorated HTML string
  957.    */
  958.   public function decorateContentWithDebug(sfEvent $event, $content)
  959.   {
  960.     // don't decorate if not html or if content is null
  961.     if (!$content || false === strpos($event['response']->getContentType(), 'html'))
  962.     {
  963.       return $content;
  964.     }
  966.     $this->context->getConfiguration()->loadHelpers(array('Helper', 'Url', 'Asset', 'Tag'));
  968.     $sf_cache_key = $this->generateCacheKey($event['uri']);
  969.     $bgColor      = $event['new'] ? '#9ff' : '#ff9';
  970.     $lastModified = $this->cache->getLastModified($sf_cache_key);
  971.     $cacheKey     = $this->cache->getOption('prefix').$sf_cache_key;
  972.     $id           = md5($event['uri']);
  974.     return '
  975.       <div id="main_'.$id.'" class="sfWebDebugActionCache" style="border: 1px solid #f00">
  976.       <div id="sub_main_'.$id.'" class="sfWebDebugCache" style="background-color: '.$bgColor.'; border-right: 1px solid #f00; border-bottom: 1px solid #f00;">
  977.       <div style="height: 16px; padding: 2px"><a href="#" onclick="sfWebDebugToggle(\'sub_main_info_'.$id.'\'); return false;"><strong>cache information</strong></a>&nbsp;<a href="#" onclick="sfWebDebugToggle(\'sub_main_'.$id.'\'); document.getElementById(\'main_'.$id.'\').style.border = \'none\'; return false;">'.image_tag(sfConfig::get('sf_web_debug_web_dir').'/images/close.png', array('alt' => 'close')).'</a>&nbsp;</div>
  978.         <div style="padding: 2px; display: none" id="sub_main_info_'.$id.'">
  979.         [uri]&nbsp;'.htmlspecialchars($event['uri'], ENT_QUOTES, sfConfig::get('sf_charset')).'<br />
  980.         [key&nbsp;for&nbsp;cache]&nbsp;'.htmlspecialchars($cacheKey, ENT_QUOTES, sfConfig::get('sf_charset')).'<br />
  981.         [life&nbsp;time]&nbsp;'.$this->getLifeTime($event['uri']).'&nbsp;seconds<br />
  982.         [last&nbsp;modified]&nbsp;'.(time() - $lastModified).'&nbsp;seconds<br />
  983.         &nbsp;<br />&nbsp;
  984.         </div>
  985.       </div><div>
  986.       '.$content.'
  987.       </div></div>
  988.     ';
  989.   }
  990. }
Debug toolbar