[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 {
  17      /**
  18      * cache for Smarty_CacheResource instances
  19      * @var array
  20      */
  21      public static $resources = array();
  22  
  23      /**
  24      * resource types provided by the core
  25      * @var array
  26      */
  27      protected static $sysplugins = array(
  28          'file' => true,
  29      );
  30  
  31      /**
  32      * populate Cached Object with meta data from Resource
  33      *
  34      * @param Smarty_Template_Cached $cached cached object
  35      * @param Smarty_Internal_Template $_template template object
  36      * @return void
  37      */
  38      public abstract function populate(Smarty_Template_Cached $cached, Smarty_Internal_Template $_template);
  39  
  40      /**
  41      * populate Cached Object with timestamp and exists from Resource
  42      *
  43      * @param Smarty_Template_Cached $source cached object
  44      * @return void
  45      */
  46      public abstract function populateTimestamp(Smarty_Template_Cached $cached);
  47  
  48      /**
  49      * Read the cached template and process header
  50      *
  51      * @param Smarty_Internal_Template $_template template object
  52      * @param Smarty_Template_Cached $cached cached object
  53      * @return booelan true or false if the cached content does not exist
  54      */
  55      public abstract function process(Smarty_Internal_Template $_template, Smarty_Template_Cached $cached=null);
  56  
  57      /**
  58      * Write the rendered template output to cache
  59      *
  60      * @param Smarty_Internal_Template $_template template object
  61      * @param string $content content to cache
  62      * @return boolean success
  63      */
  64      public abstract function writeCachedContent(Smarty_Internal_Template $_template, $content);
  65  
  66      /**
  67      * Return cached content
  68      *
  69      * @param Smarty_Internal_Template $_template template object
  70      * @param string $content content of cache
  71      */
  72      public function getCachedContent(Smarty_Internal_Template $_template)
  73      {
  74          if ($_template->cached->handler->process($_template)) {
  75              ob_start();
  76              $_template->properties['unifunc']($_template);
  77              return ob_get_clean();
  78          }
  79          return null;
  80      }
  81  
  82      /**
  83      * Empty cache
  84      *
  85      * @param Smarty $smarty Smarty object
  86      * @param integer $exp_time expiration time (number of seconds, not timestamp)
  87      * @return integer number of cache files deleted
  88      */
  89      public abstract function clearAll(Smarty $smarty, $exp_time=null);
  90  
  91      /**
  92      * Empty cache for a specific template
  93      *
  94      * @param Smarty $smarty Smarty object
  95      * @param string $resource_name template name
  96      * @param string $cache_id cache id
  97      * @param string $compile_id compile id
  98      * @param integer $exp_time expiration time (number of seconds, not timestamp)
  99      * @return integer number of cache files deleted
 100      */
 101      public abstract function clear(Smarty $smarty, $resource_name, $cache_id, $compile_id, $exp_time);
 102  
 103  
 104      public function locked(Smarty $smarty, Smarty_Template_Cached $cached)
 105      {
 106          // theoretically locking_timeout should be checked against time_limit (max_execution_time)
 107          $start = microtime(true);
 108          $hadLock = null;
 109          while ($this->hasLock($smarty, $cached)) {
 110              $hadLock = true;
 111              if (microtime(true) - $start > $smarty->locking_timeout) {
 112                  // abort waiting for lock release
 113                  return false;
 114              }
 115              sleep(1);
 116          }
 117          return $hadLock;
 118      }
 119  
 120      public function hasLock(Smarty $smarty, Smarty_Template_Cached $cached)
 121      {
 122          // check if lock exists
 123          return false;
 124      }
 125  
 126      public function acquireLock(Smarty $smarty, Smarty_Template_Cached $cached)
 127      {
 128          // create lock
 129          return true;
 130      }
 131  
 132      public function releaseLock(Smarty $smarty, Smarty_Template_Cached $cached)
 133      {
 134          // release lock
 135          return true;
 136      }
 137  
 138  
 139      /**
 140      * Load Cache Resource Handler
 141      *
 142      * @param Smarty $smarty Smarty object
 143      * @param string $type name of the cache resource
 144      * @return Smarty_CacheResource Cache Resource Handler
 145      */
 146      public static function load(Smarty $smarty, $type = null)
 147      {
 148          if (!isset($type)) {
 149              $type = $smarty->caching_type;
 150          }
 151  
 152          // try smarty's cache
 153          if (isset($smarty->_cacheresource_handlers[$type])) {
 154              return $smarty->_cacheresource_handlers[$type];
 155          }
 156          
 157          // try registered resource
 158          if (isset($smarty->registered_cache_resources[$type])) {
 159              // do not cache these instances as they may vary from instance to instance
 160              return $smarty->_cacheresource_handlers[$type] = $smarty->registered_cache_resources[$type];
 161          }
 162          // try sysplugins dir
 163          if (isset(self::$sysplugins[$type])) {
 164              if (!isset(self::$resources[$type])) {
 165                  $cache_resource_class = 'Smarty_Internal_CacheResource_' . ucfirst($type);
 166                  self::$resources[$type] = new $cache_resource_class();
 167              }
 168              return $smarty->_cacheresource_handlers[$type] = self::$resources[$type];
 169          }
 170          // try plugins dir
 171          $cache_resource_class = 'Smarty_CacheResource_' . ucfirst($type);
 172          if ($smarty->loadPlugin($cache_resource_class)) {
 173              if (!isset(self::$resources[$type])) {
 174                  self::$resources[$type] = new $cache_resource_class();
 175              }
 176              return $smarty->_cacheresource_handlers[$type] = self::$resources[$type];
 177          }
 178          // give up
 179          throw new SmartyException("Unable to load cache resource '{$type}'");
 180      }
 181  
 182      /**
 183      * Invalid Loaded Cache Files
 184      *
 185      * @param Smarty $smarty Smarty object
 186      */
 187      public static function invalidLoadedCache(Smarty $smarty)
 188      {
 189          foreach ($smarty->template_objects as $tpl) {
 190              if (isset($tpl->cached)) {
 191                  $tpl->cached->valid = false;
 192                  $tpl->cached->processed = false;
 193              }
 194          }
 195      }
 196  }
 197  
 198  /**
 199  * Smarty Resource Data Object
 200  *
 201  * Cache Data Container for Template Files
 202  *
 203  * @package Smarty
 204  * @subpackage TemplateResources
 205  * @author Rodney Rehm
 206  */
 207  class Smarty_Template_Cached {
 208      /**
 209      * Source Filepath
 210      * @var string
 211      */
 212      public $filepath = false;
 213  
 214      /**
 215      * Source Content
 216      * @var string
 217      */
 218      public $content = null;
 219  
 220      /**
 221      * Source Timestamp
 222      * @var integer
 223      */
 224      public $timestamp = false;
 225  
 226      /**
 227      * Source Existance
 228      * @var boolean
 229      */
 230      public $exists = false;
 231  
 232      /**
 233      * Cache Is Valid
 234      * @var boolean
 235      */
 236      public $valid = false;
 237  
 238      /**
 239      * Cache was processed
 240      * @var boolean
 241      */
 242      public $processed = false;
 243  
 244      /**
 245      * CacheResource Handler
 246      * @var Smarty_CacheResource
 247      */
 248      public $handler = null;
 249  
 250      /**
 251      * Template Compile Id (Smarty_Internal_Template::$compile_id)
 252      * @var string
 253      */
 254      public $compile_id = null;
 255  
 256      /**
 257      * Template Cache Id (Smarty_Internal_Template::$cache_id)
 258      * @var string
 259      */
 260      public $cache_id = null;
 261  
 262      /**
 263      * Id for cache locking
 264      * @var string
 265      */
 266      public $lock_id = null;
 267  
 268      /**
 269      * flag that cache is locked by this instance
 270      * @var bool
 271      */
 272      public $is_locked = false;
 273  
 274      /**
 275      * Source Object
 276      * @var Smarty_Template_Source
 277      */
 278      public $source = null;
 279  
 280      /**
 281      * create Cached Object container
 282      *
 283      * @param Smarty_Internal_Template $_template template object
 284      */
 285      public function __construct(Smarty_Internal_Template $_template)
 286      {
 287          $this->compile_id = $_template->compile_id;
 288          $this->cache_id = $_template->cache_id;
 289          $this->source = $_template->source;
 290          $_template->cached = $this;
 291          $smarty = $_template->smarty;
 292  
 293          //
 294          // load resource handler
 295          //
 296          $this->handler = $handler = Smarty_CacheResource::load($smarty); // Note: prone to circular references
 297  
 298          //
 299          //    check if cache is valid
 300          //
 301          if (!($_template->caching == Smarty::CACHING_LIFETIME_CURRENT || $_template->caching == Smarty::CACHING_LIFETIME_SAVED) || $_template->source->recompiled) {
 302              $handler->populate($this, $_template);
 303              return;
 304          }
 305          while (true) {
 306              while (true) {
 307                  $handler->populate($this, $_template);
 308                  if ($this->timestamp === false || $smarty->force_compile || $smarty->force_cache) {
 309                      $this->valid = false;
 310                  } else {
 311                      $this->valid = true;
 312                  }
 313                  if ($this->valid && $_template->caching == Smarty::CACHING_LIFETIME_CURRENT && $_template->cache_lifetime >= 0 && time() > ($this->timestamp + $_template->cache_lifetime)) {
 314                      // lifetime expired
 315                      $this->valid = false;
 316                  }
 317                  if ($this->valid || !$_template->smarty->cache_locking) {
 318                      break;
 319                  }
 320                  if (!$this->handler->locked($_template->smarty, $this)) {
 321                      $this->handler->acquireLock($_template->smarty, $this);
 322                      break 2;
 323                  }
 324              }
 325              if ($this->valid) {
 326                  if (!$_template->smarty->cache_locking || $this->handler->locked($_template->smarty, $this) === null) {
 327                      // load cache file for the following checks
 328                      if ($smarty->debugging) {
 329                          Smarty_Internal_Debug::start_cache($_template);
 330                      }
 331                      if($handler->process($_template, $this) === false) {
 332                          $this->valid = false;
 333                      } else {
 334                          $this->processed = true;
 335                      }
 336                      if ($smarty->debugging) {
 337                          Smarty_Internal_Debug::end_cache($_template);
 338                      }
 339                  } else {
 340                      continue;
 341                  }
 342              } else {
 343                  return;
 344              }
 345              if ($this->valid && $_template->caching === Smarty::CACHING_LIFETIME_SAVED && $_template->properties['cache_lifetime'] >= 0 && (time() > ($_template->cached->timestamp + $_template->properties['cache_lifetime']))) {
 346                  $this->valid = false;
 347              }
 348              if (!$this->valid && $_template->smarty->cache_locking) {
 349                  $this->handler->acquireLock($_template->smarty, $this);
 350                  return;
 351              } else {
 352                  return;
 353              }
 354          }
 355      }
 356  
 357      /**
 358      * Write this cache object to handler
 359      *
 360      * @param Smarty_Internal_Template $_template template object
 361      * @param string $content content to cache
 362      * @return boolean success
 363      */
 364      public function write(Smarty_Internal_Template $_template, $content)
 365      {
 366          if (!$_template->source->recompiled) {
 367              if ($this->handler->writeCachedContent($_template, $content)) {
 368                  $this->timestamp = time();
 369                  $this->exists = true;
 370                  $this->valid = true;
 371                  if ($_template->smarty->cache_locking) {
 372                      $this->handler->releaseLock($_template->smarty, $this);
 373                  }
 374                  return true;
 375              }
 376          }
 377          return false;
 378      }
 379  
 380  }
 381  ?>