library/smarty/libs/sysplugins/smarty_cacheresource.php
changeset 0 4869aea77e21
equal deleted inserted replaced
-1:000000000000 0:4869aea77e21
       
     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      * resource types provided by the core
       
    19      *
       
    20      * @var array
       
    21      */
       
    22     protected static $sysplugins = array(
       
    23         'file' => 'smarty_internal_cacheresource_file.php',
       
    24     );
       
    25 
       
    26     /**
       
    27      * populate Cached Object with meta data from Resource
       
    28      *
       
    29      * @param Smarty_Template_Cached $cached cached object
       
    30      * @param Smarty_Internal_Template $_template template object
       
    31      *
       
    32      * @return void
       
    33      */
       
    34     abstract public function populate(Smarty_Template_Cached $cached, Smarty_Internal_Template $_template);
       
    35 
       
    36     /**
       
    37      * populate Cached Object with timestamp and exists from Resource
       
    38      *
       
    39      * @param Smarty_Template_Cached $cached
       
    40      *
       
    41      * @return void
       
    42      */
       
    43     abstract public function populateTimestamp(Smarty_Template_Cached $cached);
       
    44 
       
    45     /**
       
    46      * Read the cached template and process header
       
    47      *
       
    48      * @param Smarty_Internal_Template $_template template object
       
    49      * @param Smarty_Template_Cached $cached cached object
       
    50      *
       
    51      * @return boolean true or false if the cached content does not exist
       
    52      */
       
    53     abstract public function process(Smarty_Internal_Template $_template, Smarty_Template_Cached $cached = null);
       
    54 
       
    55     /**
       
    56      * Write the rendered template output to cache
       
    57      *
       
    58      * @param Smarty_Internal_Template $_template template object
       
    59      * @param string $content content to cache
       
    60      *
       
    61      * @return boolean success
       
    62      */
       
    63     abstract public function writeCachedContent(Smarty_Internal_Template $_template, $content);
       
    64 
       
    65     /**
       
    66      * Return cached content
       
    67      *
       
    68      * @param Smarty_Internal_Template $_template template object
       
    69      *
       
    70      * @return null|string
       
    71      */
       
    72     public function getCachedContent(Smarty_Internal_Template $_template) {
       
    73         if ($_template->cached->handler->process($_template)) {
       
    74             ob_start();
       
    75             $_template->properties['unifunc']($_template);
       
    76 
       
    77             return ob_get_clean();
       
    78         }
       
    79 
       
    80         return null;
       
    81     }
       
    82 
       
    83     /**
       
    84      * Empty cache
       
    85      *
       
    86      * @param Smarty $smarty Smarty object
       
    87      * @param integer $exp_time expiration time (number of seconds, not timestamp)
       
    88      *
       
    89      * @return integer number of cache files deleted
       
    90      */
       
    91     abstract public function clearAll(Smarty $smarty, $exp_time = null);
       
    92 
       
    93     /**
       
    94      * Empty cache for a specific template
       
    95      *
       
    96      * @param Smarty $smarty Smarty object
       
    97      * @param string $resource_name template name
       
    98      * @param string $cache_id cache id
       
    99      * @param string $compile_id compile id
       
   100      * @param integer $exp_time expiration time (number of seconds, not timestamp)
       
   101      *
       
   102      * @return integer number of cache files deleted
       
   103      */
       
   104     abstract public function clear(Smarty $smarty, $resource_name, $cache_id, $compile_id, $exp_time);
       
   105 
       
   106     /**
       
   107      * @param Smarty $smarty
       
   108      * @param Smarty_Template_Cached $cached
       
   109      *
       
   110      * @return bool|null
       
   111      */
       
   112     public function locked(Smarty $smarty, Smarty_Template_Cached $cached) {
       
   113         // theoretically locking_timeout should be checked against time_limit (max_execution_time)
       
   114         $start = microtime(true);
       
   115         $hadLock = null;
       
   116         while ($this->hasLock($smarty, $cached)) {
       
   117             $hadLock = true;
       
   118             if (microtime(true) - $start > $smarty->locking_timeout) {
       
   119                 // abort waiting for lock release
       
   120                 return false;
       
   121             }
       
   122             sleep(1);
       
   123         }
       
   124 
       
   125         return $hadLock;
       
   126     }
       
   127 
       
   128     /**
       
   129      * Check is cache is locked for this template
       
   130      *
       
   131      * @param Smarty $smarty
       
   132      * @param Smarty_Template_Cached $cached
       
   133      *
       
   134      * @return bool
       
   135      */
       
   136     public function hasLock(Smarty $smarty, Smarty_Template_Cached $cached) {
       
   137         // check if lock exists
       
   138         return false;
       
   139     }
       
   140 
       
   141     /**
       
   142      * Lock cache for this template
       
   143      *
       
   144      * @param Smarty $smarty
       
   145      * @param Smarty_Template_Cached $cached
       
   146      *
       
   147      * @return bool
       
   148      */
       
   149     public function acquireLock(Smarty $smarty, Smarty_Template_Cached $cached) {
       
   150         // create lock
       
   151         return true;
       
   152     }
       
   153 
       
   154     /**
       
   155      * Unlock cache for this template
       
   156      *
       
   157      * @param Smarty $smarty
       
   158      * @param Smarty_Template_Cached $cached
       
   159      *
       
   160      * @return bool
       
   161      */
       
   162     public function releaseLock(Smarty $smarty, Smarty_Template_Cached $cached) {
       
   163         // release lock
       
   164         return true;
       
   165     }
       
   166 
       
   167     /**
       
   168      * Load Cache Resource Handler
       
   169      *
       
   170      * @param Smarty $smarty Smarty object
       
   171      * @param string $type name of the cache resource
       
   172      *
       
   173      * @throws SmartyException
       
   174      * @return Smarty_CacheResource Cache Resource Handler
       
   175      */
       
   176     public static function load(Smarty $smarty, $type = null) {
       
   177         if (!isset($type)) {
       
   178             $type = $smarty->caching_type;
       
   179         }
       
   180 
       
   181         // try smarty's cache
       
   182         if (isset($smarty->_cacheresource_handlers[$type])) {
       
   183             return $smarty->_cacheresource_handlers[$type];
       
   184         }
       
   185 
       
   186         // try registered resource
       
   187         if (isset($smarty->registered_cache_resources[$type])) {
       
   188             // do not cache these instances as they may vary from instance to instance
       
   189             return $smarty->_cacheresource_handlers[$type] = $smarty->registered_cache_resources[$type];
       
   190         }
       
   191         // try sysplugins dir
       
   192         if (isset(self::$sysplugins[$type])) {
       
   193             $cache_resource_class = 'Smarty_Internal_CacheResource_' . ucfirst($type);
       
   194             if (!class_exists($cache_resource_class, false)) {
       
   195                 require SMARTY_SYSPLUGINS_DIR . self::$sysplugins[$type];
       
   196             }
       
   197             return $smarty->_cacheresource_handlers[$type] = new $cache_resource_class();
       
   198         }
       
   199         // try plugins dir
       
   200         $cache_resource_class = 'Smarty_CacheResource_' . ucfirst($type);
       
   201         if ($smarty->loadPlugin($cache_resource_class)) {
       
   202             return $smarty->_cacheresource_handlers[$type] = new $cache_resource_class();
       
   203         }
       
   204         // give up
       
   205         throw new SmartyException("Unable to load cache resource '{$type}'");
       
   206     }
       
   207 
       
   208     /**
       
   209      * Invalid Loaded Cache Files
       
   210      *
       
   211      * @param Smarty $smarty Smarty object
       
   212      */
       
   213     public static function invalidLoadedCache(Smarty $smarty) {
       
   214         foreach ($smarty->template_objects as $tpl) {
       
   215             if (isset($tpl->cached)) {
       
   216                 $tpl->cached->valid = false;
       
   217                 $tpl->cached->processed = false;
       
   218             }
       
   219         }
       
   220     }
       
   221 }