mbirth/LuckyCoinkydink
Archived
1
0
Fork 0
Code Issues Pull Requests Activity

remove in-memory caching, 60e15aa, since this needs to have enabled cache set

Browse Source 
Since this is not possible with current template structure in Serendipity, this also removes the serendipity_smarty_class caching section and its notes to a text file.
This commit is contained in:
Ian
2014-11-02 14:23:30 +01:00
parent 0ce1d8991d
commit e11cbbc88f
3 changed files with 182 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
include/README_SMARTY_CACHING_PURPOSES.txt Normal file
View File

@ -0,0 +1,124 @@
// enable properties with removing #cache#
#cache# $this->setCacheDir($serendipity['serendipityPath'] . 'cache');
#cache# $this->caching = true; // $this->setCaching(true);
/*
Caching is disabled, as long as we haven't figured out on how to use it best here....
Note: rodneyrehm
A cache_id is (ideally) supposed to identify a single page.
md5(REQUEST_URI) may _seem_ to be doing that, but /foo.html and /foo.html?foo=bar are the same resource
from S9Y's point of view - with DIFFERENT REQUEST_URIs. Your approach leads to a number of problems:
* flooding the cache space with duplicate content
* essentially making clearCache() useless, as md5 checksums of /foo.html and /foo.html?foo=bar have
exactly nothing in common.
You want to specify the pieces of cachable content yourself. Go with a structure like
post-123
post-123|comments (if you have a page for all comments belonging to that post)
post-123|comments|feed (if you have a comment feed for a certain post)
now you can clearCache('post-123') and comments and comments|feed are killed as well.
*/
/*
// APC and MEMCACHE are loaded from this libs plugins folder,
// but you need to have enabled caching by $smarty->caching = true (see Rodneys upper template structure note),
// which makes clear why we can't use Smarty caching currently with S9y
// enable for APC in-memory (RAM) storage caching - must be enabled in PHP
if(APC_EXTENSION_LOADED && !$serendipity['disable_apc']) {
$this->addPluginsDir ( SMARTY_DIR . 'plugins/' );
$this->caching_type = 'apc'; //$this->setCachingType ( 'apc' );
}
// enable for MEMCACHE storage caching - must be enabled in PHP
if(MEMCACHE_EXTENSION_LOADED && !$serendipity['disable_memcache']) {
$this->addPluginsDir ( SMARTY_DIR . 'plugins/' );
$this->caching_type = 'memcache'; //$this->setCachingType ( 'memcache' );
}
*/
// does set cache also need to be set to true?
#cache# $this->cache_modified_check = true; // to be used with display() method only, must be true to enable 304 headers
/*
Note: rodneyrehm
$cache_modified_check only works if you're using display() - it won't do anything on fetch().
It won't do anything if you have non-caching plugins or {insert} tags, either.
We're working on making this more intelligent for 3.2, but? work with what you've got in 3.1 first.
*/
// some documentary from the smarty forum
/*
With Smarty::CACHING_LIFETIME_SAVED the expiration date is written into the cached file.
So each cache_id / compile_id combination may have their own cache lifetime.
The point is simply, that once the cache lifetime (expiration date) has been saved to the cache file,
it cannot be altered except for clearing and regenerating said cache file
Template Inheritance
Using is_cached() on sub-templates has to set up caching before is_cached() calls,
e.g if (!$smarty->isCached('sub_test.tpl')) { $smarty->assign('foo', $foo); }.
The subtemplate will always be cached as specified in the {include} tag.
Otherwise you could never cache a subtemplate with caching disabled for the main template.
If you don't want to have the main template cached, turn caching off again after the is_cached() calls for the subtemplate.
So the example will cache sub_test.tpl, but not test.tpl
Using is_cached() on subtemplates has to set up caching before is_cached() calls.
The subtemplate will always be cached as specified in the {include} tag.
Otherwise you could never cache a subtemplate with caching disabled for the main template.
If you don't want to have the main template cached, turn caching off again after the is_cached() calls for the subtemplate.
So the example will cache sub_test.tpl but not test.tpl
Use $smarty->caching = Smarty::CACHING_LIFETIME_SAVED; with {include file="sub_test.tpl" cache_lifetime="120"} in test.tpl;
Use $smarty->caching = Smarty::CACHING_LIFETIME_CURRENT; with {include .... caching}
*/
#cache# $this->caching = Smarty::CACHING_LIFETIME_CURRENT; // $this->setCaching(2); // 1 will change the end of lifetime immediately.
# $this->caching = Smarty::CACHING_LIFETIME_SAVED; // $this->setCaching(Smarty::CACHING_LIFETIME_SAVED);
# $this->caching = Smarty::CACHING_OFF; // $this->setCaching(Smarty::CACHING_OFF) // stop caching >= 3.1.4
/*
Note: rodneyrehm
The CACHING_LIFETIME_SAVED option is something you only really "need" if many cache files have different lifetimes.
I've used Smarty intensively over the past years and I _never_ required LIFETIME_SAVED...
you can do $force_cache = true; to make the current page re-render to cache. This actually allows you to work with a very high
cache_lifetime and poll a secondary modified time from somewhere. You could then implement the serve-stale-until-updated caching approach.
I'll blog about this? probably around christmas
*/
// set the cache_lifetime for index.tpl to 5 minutes
#cache# $this->cache_lifetime = 300; // $this->setCacheLifetime(300); // 86400; // one day: 60*60*24
// some documentary from the smarty forum
/*
Smarty caching is based purely on the fetch() or display() call. So:
$smarty->fetch('application.tpl');
Will generate a cached output and use that on repeated calls. If you have multiple versions of this call, you need to pass a cache_id. Example:
$cache_id = md5($_SERVER['REQUEST_URI']);
$smarty->fetch('application.tpl',$cache_id);
It is entirely up to you what is taken into account for the cache_id (URL, etc.)
*/
// does this mean $this->setCacheId($id); is useless here and has to be set where the actual templates are called? or does ist work as something default?
/*
Note: rodneyrehm
when fetch(tpl) is called, Smarty::$cache_id is injected. If you need a single cache_id for the whole render complex, this may be the sane thing to do.
But you'll probably segment certain content. A Post does not have to be reendered for every new comment. It thus makes sense to separate these entities
into their own cache spaces. In turn they'd probably receive their own cache_ids. Although that is not _necessary_ as template_name and cache_id work in
conjunction. If both are supplied (to say clearCache()) template_name increases the specificity of cache_id, so only those items are purged that meet
both criteria.
*/
// some documentary from the smarty forum
/*
Smarty will use the cache_id for distributing the cache files into sub_dirs
A cache id is used if you cache different output generated by the same template as for example on a product page.
In such a case you should use a product id as cache id.
$this->cache_id($id); // $this->setCacheId($id);
*/
#cache# $this->cache_id = md5($_SERVER['REQUEST_URI']); // this isn't a good idea either, better have it disabled or use a special id
/*
Note: Ian
What kind of Serendipity ID could this be?
- see Rodneys first caching note
*/

14
include/functions_smarty.inc.php
View File

@ -1,4 +1,4 @@
<?php # $Id$
<?php
# Copyright (c) 2003-2005, Jannis Hermanns (on behalf the Serendipity Developer Team)
# All rights reserved. See LICENSE file for licensing details
@ -885,7 +885,9 @@ function serendipity_smarty_init($vars = array()) {
global $serendipity, $template_config, $template_global_config, $template_config_groups;
if (!isset($serendipity['smarty'])) {
$template_dir = $serendipity['serendipityPath'] . $serendipity['templatePath'] . $serendipity['template'];
if (!defined('IN_serendipity_admin') && file_exists($template_dir . '/template.inc.php')) {
// If this file exists, a custom template engine will be loaded.
// Beware: Smarty is used in the Admin backend, despite of this.
@ -905,9 +907,9 @@ function serendipity_smarty_init($vars = array()) {
@define('SMARTY_RESOURCE_CHAR_SET', LANG_CHARSET);
}
// define cache resources to load with smarty - see smarty class
@define('APC_EXTENSION_LOADED', extension_loaded('apc') && ini_get('apc.enabled'));
@define('MEMCACHE_EXTENSION_LOADED', (class_exists('Memcached',false) || class_exists('Memcache',false)) && (extension_loaded("memcached") || extension_loaded("memcache")));
// define cache resources to load with smarty - see smarty cache readme - needs enabled cache!
#@define('APC_EXTENSION_LOADED', extension_loaded('apc') && ini_get('apc.enabled'));
#@define('MEMCACHE_EXTENSION_LOADED', (class_exists('Memcached',false) || class_exists('Memcache',false)) && (extension_loaded("memcached") || extension_loaded("memcache")));
// Default Smarty Engine will be used
@define('SMARTY_DIR', S9Y_PEAR_PATH . 'Smarty/libs/');
@ -943,10 +945,12 @@ function serendipity_smarty_init($vars = array()) {
// debugging...
#echo '<pre>';print_r($serendipity['smarty']);echo '</pre>';#exit;
#$serendipity['smarty']->testInstall();exit;
// extreme debugging with undocumented internal flag which enables a trace output from the parser during debugging
#$serendipity['smarty']->_parserdebug = true; // be careful!
/**
* ToDo: Check for possible API changes in Smarty 3.2 [smarty_modifier_foobar, --> [smarty_modifier_foobar, smarty_function_foobar, smarty_block_foobar] (in class)]
* smarty_modifier_foobar(Smarty $smarty, $string, <EFBFBD>) vs. smarty_modifier_foobar($string, <EFBFBD>)
* smarty_modifier_foobar(Smarty $smarty, $string, ...) vs. smarty_modifier_foobar($string, ...)
**/
$serendipity['smarty']->registerPlugin('modifier', 'makeFilename', 'serendipity_makeFilename');
$serendipity['smarty']->registerPlugin('modifier', 'xhtml_target', 'serendipity_xhtml_target');

124
include/serendipity_smarty_class.inc.php
View File

@ -1,5 +1,5 @@
<?php
// serendipity_smarty_class.inc.php 2013-01-24 Ian
// serendipity_smarty_class.inc.php lm 2014-11-02 Ian
// define secure_dir and trusted_dirs for Serendipity_Smarty_Security_Policy class.
@define('S9Y_TEMPLATE_FALLBACK', $serendipity['serendipityPath'] . $serendipity['templatePath'] . 'default');
@ -121,6 +121,7 @@ class Serendipity_Smarty extends Smarty
$template_engine = serendipity_get_config_var('template_engine');
$template_dirs = array();
if ($template_engine) {
$p = explode(',', $template_engine);
foreach($p AS $te) {
@ -154,7 +155,6 @@ class Serendipity_Smarty extends Smarty
trigger_error(sprintf(DIRECTORY_WRITE_ERROR, $this->getCompileDir()), E_USER_ERROR);
}
#cache# $this->setCacheDir($serendipity['serendipityPath'] . 'cache'); // (enable #cache# properties)
/*
here we go with our other Smarty class properties, which can all be called by their property name (recommended)
@ -163,129 +163,17 @@ class Serendipity_Smarty extends Smarty
Note: rodneyrehm - From within the Smarty class context you can safely access properties like Smarty::$use_sub_dirs directly.
*/
/* +++++++++++++++++++++++++++++++++++
Set Smarty caching
*/
// enable for APC in-memory (RAM) storage caching - must be enabled in PHP
if(APC_EXTENSION_LOADED && !$serendipity['disable_apc']) {
$this->addPluginsDir ( SMARTY_DIR . 'plugins/' );
$this->caching_type = 'apc'; //$this->setCachingType ( 'apc' );
}
// enable for MEMCACHE storage caching - must be enabled in PHP
if(MEMCACHE_EXTENSION_LOADED && !$serendipity['disable_memcache']) {
$this->addPluginsDir ( SMARTY_DIR . 'plugins/' );
$this->caching_type = 'memcache'; //$this->setCachingType ( 'memcache' );
}
/*
Caching is disabled, as long as we haven't figured out on how to use it best here....
Note: rodneyrehm
A cache_id is (ideally) supposed to identify a single page.
md5(REQUEST_URI) may _seem_ to be doing that, but /foo.html and /foo.html?foo=bar are the same resource
from S9Y's point of view - with DIFFERENT REQUEST_URIs. Your approach leads to a number of problems:
* flooding the cache space with duplicate content
* essentially making clearCache() useless, as md5 checksums of /foo.html and /foo.html?foo=bar have
exactly nothing in common.
You want to specify the pieces of cachable content yourself. Go with a structure like
post-123
post-123|comments (if you have a page for all comments belonging to that post)
post-123|comments|feed (if you have a comment feed for a certain post)
now you can clearCache('post-123') and comments and comments|feed are killed as well.
*/
// does set cache also need to be set to true?
#cache# $this->cache_modified_check = true; // to be used with display() method only, must be true to enable 304 headers
/*
Note: rodneyrehm
$cache_modified_check only works if you're using display() - it won't do anything on fetch().
It won't do anything if you have non-caching plugins or {insert} tags, either.
We're working on making this more intelligent for 3.2, but<75> work with what you've got in 3.1 first.
*/
// some documentary from the smarty forum
/*
With Smarty::CACHING_LIFETIME_SAVED the expiration date is written into the cached file.
So each cache_id / compile_id combination may have their own cache lifetime.
The point is simply, that once the cache lifetime (expiration date) has been saved to the cache file,
it cannot be altered except for clearing and regenerating said cache file
Template Inheritance
Using is_cached() on sub-templates has to set up caching before is_cached() calls,
e.g if (!$smarty->isCached('sub_test.tpl')) { $smarty->assign('foo', $foo); }.
The subtemplate will always be cached as specified in the {include} tag.
Otherwise you could never cache a subtemplate with caching disabled for the main template.
If you don't want to have the main template cached, turn caching off again after the is_cached() calls for the subtemplate.
So the example will cache sub_test.tpl, but not test.tpl
Using is_cached() on subtemplates has to set up caching before is_cached() calls.
The subtemplate will always be cached as specified in the {include} tag.
Otherwise you could never cache a subtemplate with caching disabled for the main template.
If you don't want to have the main template cached, turn caching off again after the is_cached() calls for the subtemplate.
So the example will cache sub_test.tpl but not test.tpl
Use $smarty->caching = Smarty::CACHING_LIFETIME_SAVED; with {include file="sub_test.tpl" cache_lifetime="120"} in test.tpl;
Use $smarty->caching = Smarty::CACHING_LIFETIME_CURRENT; with {include .... caching}
*/
#cache# $this->caching = Smarty::CACHING_LIFETIME_CURRENT; // $this->setCaching(2); // 1 will change the end of lifetime immediately.
# $this->caching = Smarty::CACHING_LIFETIME_SAVED; // $this->setCaching(Smarty::CACHING_LIFETIME_SAVED);
# $this->caching = Smarty::CACHING_OFF; // $this->setCaching(Smarty::CACHING_OFF) // stop caching >= 3.1.4
/*
Note: rodneyrehm
The CACHING_LIFETIME_SAVED option is something you only really "need" if many cache files have different lifetimes.
I've used Smarty intensively over the past years and I _never_ required LIFETIME_SAVED...
you can do $force_cache = true; to make the current page re-render to cache. This actually allows you to work with a very high
cache_lifetime and poll a secondary modified time from somewhere. You could then implement the serve-stale-until-updated caching approach.
I'll blog about this<69> probably around christmas
*/
// set the cache_lifetime for index.tpl to 5 minutes
#cache# $this->cache_lifetime = 300; // $this->setCacheLifetime(300); // 86400; // one day: 60*60*24
// some documentary from the smarty forum
/*
Smarty caching is based purely on the fetch() or display() call. So:
$smarty->fetch('application.tpl');
Will generate a cached output and use that on repeated calls. If you have multiple versions of this call, you need to pass a cache_id. Example:
$cache_id = md5($_SERVER['REQUEST_URI']);
$smarty->fetch('application.tpl',$cache_id);
It is entirely up to you what is taken into account for the cache_id (URL, etc.)
*/
// does this mean $this->setCacheId($id); is useless here and has to be set where the actual templates are called? or does ist work as something default?
/*
Note: rodneyrehm
when fetch(tpl) is called, Smarty::$cache_id is injected. If you need a single cache_id for the whole render complex, this may be the sane thing to do.
But you'll probably segment certain content. A Post does not have to be reendered for every new comment. It thus makes sense to separate these entities
into their own cache spaces. In turn they'd probably receive their own cache_ids. Although that is not _necessary_ as template_name and cache_id work in
conjunction. If both are supplied (to say clearCache()) template_name increases the specificity of cache_id, so only those items are purged that meet
both criteria.
*/
// some documentary from the smarty forum
/*
Smarty will use the cache_id for distributing the cache files into sub_dirs
A cache id is used if you cache different output generated by the same template as for example on a product page.
In such a case you should use a product id as cache id.
$this->cache_id($id); // $this->setCacheId($id);
*/
#cache# $this->cache_id = md5($_SERVER['REQUEST_URI']); // this isn't a good idea either, better have it disabled or use a special id
/*
Note: Ian
What kind of Serendipity ID could this be?
- see Rodneys first caching note
Set Smarty caching - outsourced to README_SMARTY_CACHING_PURPOSES.txt
Not usable in Serendipity with current template structure!
*/
/* ++++++++++++++++++++++++++++++++++++++++++++++
Set all other needed Smarty class properties
*/
#???# $this->merge_compiled_includes = true; // $this->setMergeCompiledIncludes(true); // what is this for?
#$this->merge_compiled_includes = true; // $this->setMergeCompiledIncludes(true); // With this option the subtemplate code is stored together with the calling template.
// default here to be overwritten by $serendipity['production'] == 'debug' - see below!
$this->debugging = false; // $this->setDebugging(false);