e544ed6d9a
Comparing changes: https://github.com/smarty-php/smarty/compare/v4.3.1...v4.4.1 It is noticeable that Smarty 4.3.1 does not officially support PHP 8.3. Is only supported with 4.4.0. Remark: During tests with Smarty 4.5.1, it was noticed that the following warning occurs: Deprecated: Using the unregistered function "function_exists" in a template is deprecated and will be removed in a future version. Use Smarty::registerPlugin to explicitly register a custom modifier. As of Smarty 5.X.X, templates must be revised again. The Smarty release 5.0.2 is already officially available. However, integration into FlatPress is not entirely trivial.
297 lines
11 KiB
Markdown
297 lines
11 KiB
Markdown
Custom Cache Implementation {#caching.custom}
|
|
===========================
|
|
|
|
As an alternative to using the default file-based caching mechanism, you
|
|
can specify a custom cache implementation that will be used to read,
|
|
write and clear cached files.
|
|
|
|
> **Note**
|
|
>
|
|
> In Smarty2 this used to be a callback function called
|
|
> `$cache_handler_func`. Smarty3 replaced this callback by the
|
|
> `Smarty_CacheResource` module.
|
|
|
|
With a custom cache implementation you\'re likely trying to achieve at
|
|
least one of the following goals: replace the slow filesystem by a
|
|
faster storage engine, centralize the cache to be accessible to multiple
|
|
servers.
|
|
|
|
Smarty allows CacheResource implementations to use one of the APIs
|
|
`Smarty_CacheResource_Custom` or `Smarty_CacheResource_KeyValueStore`.
|
|
`Smarty_CacheResource_Custom` is a simple API directing all read, write,
|
|
clear calls to your implementation. This API allows you to store
|
|
wherever and however you deem fit. The
|
|
`Smarty_CacheResource_KeyValueStore` API allows you to turn any \"dumb\"
|
|
KeyValue-Store (like APC, Memcache, ...) into a full-featured
|
|
CacheResource implementation. That is, everything around deep
|
|
cache-groups like \"a\|b\|c\" is being handled for you in way that
|
|
allows clearing the cache-group \"a\" and all nested groups are cleared
|
|
as well - even though KeyValue-Stores don\'t allow this kind of
|
|
hierarchy by nature.
|
|
|
|
Custom CacheResources may be put in a file `cacheresource.foobarxyz.php`
|
|
within your [`$plugins_dir`](#variable.plugins.dir), or registered on
|
|
runtime with [`registerCacheResource()`](#api.register.cacheresource).
|
|
In either case you need to set [`$caching_type`](#variable.caching.type)
|
|
to invoke your custom CacheResource implementation.
|
|
|
|
|
|
<?php
|
|
|
|
require_once 'libs/Smarty.class.php';
|
|
$smarty = new Smarty();
|
|
$smarty->caching_type = 'mysql';
|
|
|
|
/**
|
|
* MySQL CacheResource
|
|
*
|
|
* CacheResource Implementation based on the Custom API to use
|
|
* MySQL as the storage resource for Smarty's output caching.
|
|
*
|
|
* Table definition:
|
|
* <pre>CREATE TABLE IF NOT EXISTS `output_cache` (
|
|
* `id` CHAR(40) NOT NULL COMMENT 'sha1 hash',
|
|
* `name` VARCHAR(250) NOT NULL,
|
|
* `cache_id` VARCHAR(250) NULL DEFAULT NULL,
|
|
* `compile_id` VARCHAR(250) NULL DEFAULT NULL,
|
|
* `modified` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
* `content` LONGTEXT NOT NULL,
|
|
* PRIMARY KEY (`id`),
|
|
* INDEX(`name`),
|
|
* INDEX(`cache_id`),
|
|
* INDEX(`compile_id`),
|
|
* INDEX(`modified`)
|
|
* ) ENGINE = InnoDB;</pre>
|
|
*
|
|
* @package CacheResource-examples
|
|
* @author Rodney Rehm
|
|
*/
|
|
class Smarty_CacheResource_Mysql extends Smarty_CacheResource_Custom {
|
|
// PDO instance
|
|
protected $db;
|
|
protected $fetch;
|
|
protected $fetchTimestamp;
|
|
protected $save;
|
|
|
|
public function __construct() {
|
|
try {
|
|
$this->db = new PDO("mysql:dbname=test;host=127.0.0.1", "smarty", "smarty");
|
|
} catch (PDOException $e) {
|
|
throw new SmartyException('Mysql Resource failed: ' . $e->getMessage());
|
|
}
|
|
$this->fetch = $this->db->prepare('SELECT modified, content FROM output_cache WHERE id = :id');
|
|
$this->fetchTimestamp = $this->db->prepare('SELECT modified FROM output_cache WHERE id = :id');
|
|
$this->save = $this->db->prepare('REPLACE INTO output_cache (id, name, cache_id, compile_id, content)
|
|
VALUES (:id, :name, :cache_id, :compile_id, :content)');
|
|
}
|
|
|
|
/**
|
|
* fetch cached content and its modification time from data source
|
|
*
|
|
* @param string $id unique cache content identifier
|
|
* @param string $name template name
|
|
* @param string $cache_id cache id
|
|
* @param string $compile_id compile id
|
|
* @param string $content cached content
|
|
* @param integer $mtime cache modification timestamp (epoch)
|
|
* @return void
|
|
*/
|
|
protected function fetch($id, $name, $cache_id, $compile_id, &$content, &$mtime)
|
|
{
|
|
$this->fetch->execute(array('id' => $id));
|
|
$row = $this->fetch->fetch();
|
|
$this->fetch->closeCursor();
|
|
if ($row) {
|
|
$content = $row['content'];
|
|
$mtime = strtotime($row['modified']);
|
|
} else {
|
|
$content = null;
|
|
$mtime = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetch cached content's modification timestamp from data source
|
|
*
|
|
* @note implementing this method is optional. Only implement it if modification times can be accessed faster than loading the complete cached content.
|
|
* @param string $id unique cache content identifier
|
|
* @param string $name template name
|
|
* @param string $cache_id cache id
|
|
* @param string $compile_id compile id
|
|
* @return integer|boolean timestamp (epoch) the template was modified, or false if not found
|
|
*/
|
|
protected function fetchTimestamp($id, $name, $cache_id, $compile_id)
|
|
{
|
|
$this->fetchTimestamp->execute(array('id' => $id));
|
|
$mtime = strtotime($this->fetchTimestamp->fetchColumn());
|
|
$this->fetchTimestamp->closeCursor();
|
|
return $mtime;
|
|
}
|
|
|
|
/**
|
|
* Save content to cache
|
|
*
|
|
* @param string $id unique cache content identifier
|
|
* @param string $name template name
|
|
* @param string $cache_id cache id
|
|
* @param string $compile_id compile id
|
|
* @param integer|null $exp_time seconds till expiration time in seconds or null
|
|
* @param string $content content to cache
|
|
* @return boolean success
|
|
*/
|
|
protected function save($id, $name, $cache_id, $compile_id, $exp_time, $content)
|
|
{
|
|
$this->save->execute(array(
|
|
'id' => $id,
|
|
'name' => $name,
|
|
'cache_id' => $cache_id,
|
|
'compile_id' => $compile_id,
|
|
'content' => $content,
|
|
));
|
|
return !!$this->save->rowCount();
|
|
}
|
|
|
|
/**
|
|
* Delete content from cache
|
|
*
|
|
* @param string $name template name
|
|
* @param string $cache_id cache id
|
|
* @param string $compile_id compile id
|
|
* @param integer|null $exp_time seconds till expiration or null
|
|
* @return integer number of deleted caches
|
|
*/
|
|
protected function delete($name, $cache_id, $compile_id, $exp_time)
|
|
{
|
|
// delete the whole cache
|
|
if ($name === null && $cache_id === null && $compile_id === null && $exp_time === null) {
|
|
// returning the number of deleted caches would require a second query to count them
|
|
$query = $this->db->query('TRUNCATE TABLE output_cache');
|
|
return -1;
|
|
}
|
|
// build the filter
|
|
$where = array();
|
|
// equal test name
|
|
if ($name !== null) {
|
|
$where[] = 'name = ' . $this->db->quote($name);
|
|
}
|
|
// equal test compile_id
|
|
if ($compile_id !== null) {
|
|
$where[] = 'compile_id = ' . $this->db->quote($compile_id);
|
|
}
|
|
// range test expiration time
|
|
if ($exp_time !== null) {
|
|
$where[] = 'modified < DATE_SUB(NOW(), INTERVAL ' . intval($exp_time) . ' SECOND)';
|
|
}
|
|
// equal test cache_id and match sub-groups
|
|
if ($cache_id !== null) {
|
|
$where[] = '(cache_id = '. $this->db->quote($cache_id)
|
|
. ' OR cache_id LIKE '. $this->db->quote($cache_id .'|%') .')';
|
|
}
|
|
// run delete query
|
|
$query = $this->db->query('DELETE FROM output_cache WHERE ' . join(' AND ', $where));
|
|
return $query->rowCount();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
<?php
|
|
|
|
require_once 'libs/Smarty.class.php';
|
|
$smarty = new Smarty();
|
|
$smarty->caching_type = 'memcache';
|
|
|
|
/**
|
|
* Memcache CacheResource
|
|
*
|
|
* CacheResource Implementation based on the KeyValueStore API to use
|
|
* memcache as the storage resource for Smarty's output caching.
|
|
*
|
|
* Note that memcache has a limitation of 256 characters per cache-key.
|
|
* To avoid complications all cache-keys are translated to a sha1 hash.
|
|
*
|
|
* @package CacheResource-examples
|
|
* @author Rodney Rehm
|
|
*/
|
|
class Smarty_CacheResource_Memcache extends Smarty_CacheResource_KeyValueStore {
|
|
/**
|
|
* memcache instance
|
|
* @var Memcache
|
|
*/
|
|
protected $memcache = null;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->memcache = new Memcache();
|
|
$this->memcache->addServer( '127.0.0.1', 11211 );
|
|
}
|
|
|
|
/**
|
|
* Read values for a set of keys from cache
|
|
*
|
|
* @param array $keys list of keys to fetch
|
|
* @return array list of values with the given keys used as indexes
|
|
* @return boolean true on success, false on failure
|
|
*/
|
|
protected function read(array $keys)
|
|
{
|
|
$_keys = $lookup = array();
|
|
foreach ($keys as $k) {
|
|
$_k = sha1($k);
|
|
$_keys[] = $_k;
|
|
$lookup[$_k] = $k;
|
|
}
|
|
$_res = array();
|
|
$res = $this->memcache->get($_keys);
|
|
foreach ($res as $k => $v) {
|
|
$_res[$lookup[$k]] = $v;
|
|
}
|
|
return $_res;
|
|
}
|
|
|
|
/**
|
|
* Save values for a set of keys to cache
|
|
*
|
|
* @param array $keys list of values to save
|
|
* @param int $expire expiration time
|
|
* @return boolean true on success, false on failure
|
|
*/
|
|
protected function write(array $keys, $expire=null)
|
|
{
|
|
foreach ($keys as $k => $v) {
|
|
$k = sha1($k);
|
|
$this->memcache->set($k, $v, 0, $expire);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove values from cache
|
|
*
|
|
* @param array $keys list of keys to delete
|
|
* @return boolean true on success, false on failure
|
|
*/
|
|
protected function delete(array $keys)
|
|
{
|
|
foreach ($keys as $k) {
|
|
$k = sha1($k);
|
|
$this->memcache->delete($k);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove *all* values from cache
|
|
*
|
|
* @return boolean true on success, false on failure
|
|
*/
|
|
protected function purge()
|
|
{
|
|
return $this->memcache->flush();
|
|
}
|
|
}
|
|
|
|
|
|
|