[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Smarty Internal Plugin
   4   *
   5   * @package Smarty
   6   * @subpackage Cacher
   7   */
   8  
   9  /**
  10   * Cache Handler API
  11   *
  12   * @package Smarty
  13   * @subpackage Cacher
  14   * @author Rodney Rehm
  15   */
  16  abstract class Smarty_CacheResource_Custom extends Smarty_CacheResource {
  17  
  18      /**
  19       * fetch cached content and its modification time from data source
  20       *
  21       * @param string $id         unique cache content identifier
  22       * @param string $name       template name
  23       * @param string $cache_id   cache id
  24       * @param string $compile_id compile id
  25       * @param string $content    cached content
  26       * @param integer $mtime cache modification timestamp (epoch)
  27       * @return void
  28       */
  29      protected abstract function fetch($id, $name, $cache_id, $compile_id, &$content, &$mtime);
  30  
  31      /**
  32       * Fetch cached content's modification timestamp from data source
  33       *
  34       * {@internal implementing this method is optional.
  35       *  Only implement it if modification times can be accessed faster than loading the complete cached content.}}
  36       *
  37       * @param string $id         unique cache content identifier
  38       * @param string $name       template name
  39       * @param string $cache_id   cache id
  40       * @param string $compile_id compile id
  41       * @return integer|boolean timestamp (epoch) the template was modified, or false if not found
  42       */
  43      protected function fetchTimestamp($id, $name, $cache_id, $compile_id)
  44      {
  45          return null;
  46      }
  47  
  48      /**
  49       * Save content to cache
  50       *
  51       * @param string       $id         unique cache content identifier
  52       * @param string       $name       template name
  53       * @param string       $cache_id   cache id
  54       * @param string       $compile_id compile id
  55       * @param integer|null $exp_time   seconds till expiration or null
  56       * @param string $content content to cache
  57       * @return boolean success
  58       */
  59      protected abstract function save($id, $name, $cache_id, $compile_id, $exp_time, $content);
  60  
  61      /**
  62       * Delete content from cache
  63       *
  64       * @param string       $name       template name
  65       * @param string       $cache_id   cache id
  66       * @param string       $compile_id compile id
  67       * @param integer|null $exp_time   seconds till expiration time in seconds or null
  68       * @return integer number of deleted caches
  69       */
  70      protected abstract function delete($name, $cache_id, $compile_id, $exp_time);
  71  
  72      /**
  73       * populate Cached Object with meta data from Resource
  74       *
  75       * @param Smarty_Template_Cached   $cached    cached object
  76       * @param Smarty_Internal_Template $_template template object
  77       * @return void
  78       */
  79      public function populate(Smarty_Template_Cached $cached, Smarty_Internal_Template $_template)
  80      {
  81          $_cache_id = isset($cached->cache_id) ? preg_replace('![^\w\|]+!', '_', $cached->cache_id) : null;
  82          $_compile_id = isset($cached->compile_id) ? preg_replace('![^\w\|]+!', '_', $cached->compile_id) : null;
  83  
  84          $cached->filepath = sha1($cached->source->filepath . $_cache_id . $_compile_id);
  85          $this->populateTimestamp($cached);
  86      }
  87  
  88      /**
  89       * populate Cached Object with timestamp and exists from Resource
  90       *
  91       * @param Smarty_Template_Cached $source cached object
  92       * @return void
  93       */
  94      public function populateTimestamp(Smarty_Template_Cached $cached)
  95      {
  96          $mtime = $this->fetchTimestamp($cached->filepath, $cached->source->name, $cached->cache_id, $cached->compile_id);
  97          if ($mtime !== null) {
  98              $cached->timestamp = $mtime;
  99              $cached->exists = !!$cached->timestamp;
 100              return;
 101          }
 102          $timestamp = null;
 103          $this->fetch($cached->filepath, $cached->source->name, $cached->cache_id, $cached->compile_id, $cached->content, $timestamp);
 104          $cached->timestamp = isset($timestamp) ? $timestamp : false;
 105          $cached->exists = !!$cached->timestamp;
 106      }
 107  
 108      /**
 109       * Read the cached template and process the header
 110       *
 111       * @param Smarty_Internal_Template $_template template object
 112       * @param Smarty_Template_Cached $cached cached object
 113       * @return booelan true or false if the cached content does not exist
 114       */
 115      public function process(Smarty_Internal_Template $_template, Smarty_Template_Cached $cached=null)
 116      {
 117          if (!$cached) {
 118              $cached = $_template->cached;
 119          }
 120          $content = $cached->content ? $cached->content : null;
 121          $timestamp = $cached->timestamp ? $cached->timestamp : null;
 122          if ($content === null || !$timestamp) {
 123              $this->fetch(
 124                  $_template->cached->filepath,
 125                  $_template->source->name,
 126                  $_template->cache_id,
 127                  $_template->compile_id,
 128                  $content,
 129                  $timestamp
 130              );
 131          }
 132          if (isset($content)) {
 133              $_smarty_tpl = $_template;
 134              eval("?>" . $content);
 135              return true;
 136          }
 137          return false;
 138      }
 139  
 140      /**
 141       * Write the rendered template output to cache
 142       *
 143       * @param Smarty_Internal_Template $_template template object
 144       * @param string                   $content   content to cache
 145       * @return boolean success
 146       */
 147      public function writeCachedContent(Smarty_Internal_Template $_template, $content)
 148      {
 149          return $this->save(
 150              $_template->cached->filepath,
 151              $_template->source->name,
 152              $_template->cache_id,
 153              $_template->compile_id,
 154              $_template->properties['cache_lifetime'],
 155              $content
 156          );
 157      }
 158  
 159      /**
 160       * Empty cache
 161       *
 162       * @param Smarty  $smarty   Smarty object
 163       * @param integer $exp_time expiration time (number of seconds, not timestamp)
 164       * @return integer number of cache files deleted
 165       */
 166      public function clearAll(Smarty $smarty, $exp_time=null)
 167      {
 168          $this->cache = array();
 169          return $this->delete(null, null, null, $exp_time);
 170      }
 171  
 172      /**
 173       * Empty cache for a specific template
 174       *
 175       * @param Smarty  $smarty        Smarty object
 176       * @param string  $resource_name template name
 177       * @param string  $cache_id      cache id
 178       * @param string  $compile_id    compile id
 179       * @param integer $exp_time      expiration time (number of seconds, not timestamp)
 180       * @return integer number of cache files deleted
 181       */
 182      public function clear(Smarty $smarty, $resource_name, $cache_id, $compile_id, $exp_time)
 183      {
 184          $this->cache = array();
 185          return $this->delete($resource_name, $cache_id, $compile_id, $exp_time);
 186      }
 187      
 188      /**
 189       * Check is cache is locked for this template
 190       *
 191       * @param Smarty $smarty Smarty object
 192       * @param Smarty_Template_Cached $cached cached object
 193       * @return booelan true or false if cache is locked
 194       */
 195      public function hasLock(Smarty $smarty, Smarty_Template_Cached $cached)
 196      {
 197          $id = $cached->filepath;
 198          $name = $cached->source->name . '.lock';
 199          
 200          $mtime = $this->fetchTimestamp($id, $name, null, null);
 201          if ($mtime === null) {
 202              $this->fetch($id, $name, null, null, $content, $mtime);
 203          }
 204          
 205          return $mtime && time() - $mtime < $smarty->locking_timeout;
 206      }
 207  
 208      /**
 209       * Lock cache for this template
 210       *
 211       * @param Smarty $smarty Smarty object
 212       * @param Smarty_Template_Cached $cached cached object
 213       */
 214      public function acquireLock(Smarty $smarty, Smarty_Template_Cached $cached)
 215      {
 216          $cached->is_locked = true;
 217          
 218          $id = $cached->filepath;
 219          $name = $cached->source->name . '.lock';
 220          $this->save($id, $name, null, null, $smarty->locking_timeout, '');
 221      }
 222  
 223      /**
 224       * Unlock cache for this template
 225       *
 226       * @param Smarty $smarty Smarty object
 227       * @param Smarty_Template_Cached $cached cached object
 228       */
 229      public function releaseLock(Smarty $smarty, Smarty_Template_Cached $cached)
 230      {
 231          $cached->is_locked = false;
 232          
 233          $id = $cached->filepath;
 234          $name = $cached->source->name . '.lock';
 235          $this->delete($name, null, null, null);
 236      }
 237  }
 238  ?>