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