Browse Source

PSR SPIP + fix typo + on change la catégorie c'est d'actualité

svn/root/tags/v1.1.1
jluc@no-log.org 4 years ago
parent
commit
71ad04f856
  1. 15
      cachelab_fonctions.php
  2. 2
      cachelab_pipelines.php
  3. 224
      inc/cachelab.php
  4. 89
      inc/cachelab_invalideur.php
  5. 32
      inc/cachelab_utils.php
  6. 70
      inc/invalideur.php
  7. 55
      lib/microtime.inc.php
  8. 6
      paquet.xml
  9. 163
      public/cachelab_balises.php

15
cachelab_fonctions.php

@ -1,19 +1,24 @@
<?php
if (!defined('_ECRIRE_INC_VERSION')) return;
if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
include_spip('public/cachelab_balises');
// loger tous les temps des ciblages
if (!defined('LOG_CACHELAB_CHRONO'))
if (!defined('LOG_CACHELAB_CHRONO')) {
define('LOG_CACHELAB_CHRONO', false);
}
// Seuil minimal des temps de ciblage à loger dans cachelab_slow (en ms)
if (!defined('LOG_CACHELAB_SLOW'))
if (!defined('LOG_CACHELAB_SLOW')) {
define('LOG_CACHELAB_SLOW', 70);
}
// Seuil minimal du nombre de caches invalidés en un seul ciblage pour le loger dans cachelab_toomany_del
if (!defined('LOG_CACHELAB_TOOMANY_DEL'))
define('LOG_CACHELAB_TOOMANY_DEL',100);
if (!defined('LOG_CACHELAB_TOOMANY_DEL')) {
define('LOG_CACHELAB_TOOMANY_DEL', 100);
}
/* Autres constantes utilisées-définies dans inc/cachelab_invalideur :
* LOG_BALISECACHE_FILTRES

2
cachelab_pipelines.php

@ -16,5 +16,5 @@ function cachelab_insert_head_css($flux) {
.cachelab_blocs small {margin: 2px; padding: 2px; font-size: 60%;}
.cachelab_assert {background-color: orange}
</style>\n";
return $flux;
return $flux;
}

224
inc/cachelab.php

@ -16,7 +16,7 @@ include_spip('public/cachelab_utils');
* @param null $return : résultat éventuellement fourni, pour les actions list et get
* @return bool : indique si l'action a pu être appliquée ou non
*/
function cachelab_appliquer ($action, $cle, $data=null, $options='', &$return=null) {
function cachelab_appliquer($action, $cle, $data = null, $options = '', &$return = null) {
global $Memoization;
if (!isset($Memoization) or !$Memoization) {
spip_log("cachelab_appliquer ($action, $cle...) : Memoization n'est pas activé", 'cachelab_erreur');
@ -24,52 +24,56 @@ global $Memoization;
}
static $len_prefix;
if (!$len_prefix)
if (!$len_prefix) {
$len_prefix = strlen(_CACHE_NAMESPACE);
}
$joliecle = substr($cle, $len_prefix);
switch ($action) {
case 'del' :
case 'del':
$del = $Memoization->del($joliecle);
if (!$del) {
spip_log ("Échec 'del' $joliecle", 'cachelab_erreur');
spip_log("Échec 'del' $joliecle", 'cachelab_erreur');
return false;
};
break;
break;
// gérés par cachelab_cibler
case 'pass' : // passe
case 'list' : // renvoie les clés
case 'clean' : // nettoie
break;
case 'pass': // passe
case 'list': // renvoie les clés
case 'clean': // nettoie
break;
case 'list_html' : // renvoie les contenus indexés par les clés sans préfixes
case 'list_html': // renvoie les contenus indexés par les clés sans préfixes
// attention ça peut grossir !
if (!is_array($return))
if (!is_array($return)) {
$return = array();
}
$return[$joliecle] = $data['texte'];
break;
break;
case 'get' : // renvoie le 1er cache ciblé
if (!$data)
case 'get': // renvoie le 1er cache ciblé
if (!$data) {
$data = $Memoization->get($joliecle);
}
$return = $data;
break;
break;
case 'get_html' : // renvoie le contenu du 1er cache
if (!$data)
case 'get_html': // renvoie le contenu du 1er cache
if (!$data) {
$data = $Memoization->get($joliecle);
}
$return = $data['texte'];
break;
break;
default :
default:
$f = 'cachelab_appliquer_'.$action;
if (function_exists($f))
if (function_exists($f)) {
return $f($action, $cle, $data, $options, $return);
else {
spip_log ("L'action $action n'est pas définie pour cachelab_applique", 'cachelab_erreur');
} else {
spip_log("L'action $action n'est pas définie pour cachelab_applique", 'cachelab_erreur');
return false;
};
}
}
return true;
}
@ -88,18 +92,19 @@ static $len_prefix;
* la liste des stats sinon, avec éventuellement la liste des résultats s'ils sont demandés (pour 'list_html'...)
*
*/
function cachelab_cibler ($action, $conditions=array(), $options=array()) {
function cachelab_cibler($action, $conditions = array(), $options = array()) {
global $Memoization;
if (!isset($Memoization) or !$Memoization or !in_array($Memoization->methode(), array('apc', 'apcu'))) {
spip_log("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu", 'cachelab_erreur');
die ("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu");
spip_log("cachelab_cibler($action...) : Mémoization n'est pas activé avec APC ou APCu", 'cachelab_erreur');
die("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu");
}
$return = null;
// filtrage
$session = (isset($conditions['session']) ? $conditions['session'] : null);
if ($session=='courante')
if ($session=='courante') {
$session = spip_session();
}
$chemin = (isset($conditions['chemin']) ? $conditions['chemin'] : null);
$chemins = explode('|', $chemin); // sert seulement pour methode_chemin == strpos
@ -107,34 +112,35 @@ global $Memoization;
$cle_objet = (isset($conditions['cle_objet']) ? $conditions['cle_objet'] : null);
$id_objet = (isset($conditions['id_objet']) ? $conditions['id_objet'] : null);
if ($cle_objet and !$id_objet) {
spip_log("cachelab_cibler : $cle_objet inconnu\n".print_r(debug_backtrace(),1), "cachelab_erreur");
spip_log("cachelab_cibler : $cle_objet inconnu\n".print_r(debug_backtrace(), 1), 'cachelab_erreur');
$cle_objet=null;
}
// pour 'contexte' on simule un 'plus' pour donner un exemple d'extension
if (isset($conditions['contexte']) and $conditions['contexte'] and !isset($conditions['plus']))
if (isset($conditions['contexte']) and $conditions['contexte'] and !isset($conditions['plus'])) {
$conditions['plus'] = 'contexte';
}
if ($plus = (isset($conditions['plus']) ? (string)$conditions['plus'] : '')) {
$plusfunc='cachelab_ciblercache_'.$plus;
// Signature nécessaire : $plusfunc ($action, $conditions, $options, &$stats)
if (!function_exists($plusfunc)) {
spip_log ("La fonction '$plusfunc' n'est pas définie", 'cachelab_erreur');
return;
spip_log("La fonction '$plusfunc' n'est pas définie", 'cachelab_erreur');
return null;
}
}
else
} else {
$plusfunc = '';
}
// options
// explode+strpos par défaut pour les chemins
$methode_chemin = (isset ($options['methode_chemin']) ? $options['methode_chemin'] : 'strpos');
$partie_chemin = (isset ($options['partie_chemin']) ? $options['partie_chemin'] : 'tout');
$methode_chemin = (isset($options['methode_chemin']) ? $options['methode_chemin'] : 'strpos');
$partie_chemin = (isset($options['partie_chemin']) ? $options['partie_chemin'] : 'tout');
// clean par défaut
$do_clean = (isset ($options['clean']) ? $options['clean'] : (!defined('CACHELAB_CLEAN') or CACHELAB_CLEAN));
$do_clean = (isset($options['clean']) ? $options['clean'] : (!defined('CACHELAB_CLEAN') or CACHELAB_CLEAN));
// pas de listes par défaut
$do_lists = ($action == 'list') or (isset ($options['list']) and $options['list']);
include_spip ('lib/microtime.inc');
microtime_do ('begin');
$do_lists = ($action == 'list') or (isset($options['list']) and $options['list']);
include_spip('lib/microtime.inc');
microtime_do('begin');
// retours
$stats=array();
@ -146,7 +152,7 @@ global $Memoization;
$meta_derniere_modif = lire_meta('derniere_modif');
$len_prefix = strlen(_CACHE_NAMESPACE);
foreach($cache['cache_list'] as $i => $d) {
foreach ($cache['cache_list'] as $i => $d) {
// on "continue=passe au suivant" dés qu'on sait que le cache n'est pas cible
$cle = $d['info'];
@ -154,23 +160,25 @@ global $Memoization;
// on saute les caches d'autres origines
// (et les caches d'un autre _CACHE_NAMESPACE pour ce même site)
if (strpos ($cle, _CACHE_NAMESPACE) !== 0) {
if (strpos($cle, _CACHE_NAMESPACE) !== 0) {
$stats['nb_alien']++;
continue;
}
// on ne veut examiner que les caches de squelettes SPIP
if (substr($cle, $len_prefix-1, 7) != ':cache:')
if (substr($cle, $len_prefix-1, 7) != ':cache:') {
continue;
}
// effacer ou sauter les caches invalidés par une invalidation totale
// ou que apcu ne suit plus
if ($meta_derniere_modif > $d['creation_time']
or !apcu_exists($cle)) {
if ($do_clean) {
$del=$Memoization->del(substr($cle,$len_prefix));
if (!$del)
spip_log ("Echec du clean du cache $cle (création : {$d['creation_time']}, invalidation : $meta_derniere_modif)", "cachelab_erreur");
$del=$Memoization->del(substr($cle, $len_prefix));
if (!$del) {
spip_log("Echec du clean du cache $cle (création : {$d['creation_time']}, invalidation : $meta_derniere_modif)", 'cachelab_erreur');
}
$stats['nb_clean']++;
};
continue;
@ -181,44 +189,49 @@ global $Memoization;
// 1er filtrage : par la session
if ($session) {
if (substr ($cle, -9) != "_$session")
continue;
if (substr($cle, -9) != "_$session") {
continue;
}
}
// 2eme filtrage : par le chemin
if ($chemin) {
switch ($partie_chemin) {
case 'tout' :
case 'chemin' :
case 'tout':
case 'chemin':
$partie_cle = $cle;
break;
case 'fichier' :
break;
case 'fichier':
$parties = explode('/', $cle);
$partie_cle = array_pop($parties);
break;
case 'dossier' :
break;
case 'dossier':
$parties = explode('/', $cle);
$parties = array_pop($parties);
$partie_cle = array_pop($parties);
break;
default :
spip_log ("Option partie_chemin incorrecte : '$partie_chemin'", 'cachelab_erreur');
return;
break;
default:
spip_log("Option partie_chemin incorrecte : '$partie_chemin'", 'cachelab_erreur');
return null;
}
// mémo php : « continue resumes execution just before the closing curly bracket ( } ), and break resumes execution just after the closing curly bracket. »
// mémo php : « continue resumes execution just before the closing curly bracket ( } ),
// and break resumes execution just after the closing curly bracket. »
switch ($methode_chemin) {
case 'strpos' :
foreach ($chemins as $unchemin)
if ($unchemin and (strpos ($partie_cle, $unchemin) !== false))
case 'strpos':
foreach ($chemins as $unchemin) {
if ($unchemin and (strpos($partie_cle, $unchemin) !== false)) {
break 2; // trouvé : sort du foreach et du switch et poursuit le test des autres conditions
continue 2; // échec : passe à la $cle suivante
case 'regexp' :
if ($chemin and ($danslechemin = preg_match(",$chemin,i", $partie_cle)))
}
}
continue 2; // échec : passe à la $cle suivante
case 'regexp':
if ($chemin and ($danslechemin = preg_match(",$chemin,i", $partie_cle))) {
break; // trouvé : poursuit le test des autres conditions
continue 2; // échec : passe à la clé suivante
default :
spip_log ("Méthode '$methode_chemin' pas prévue pour le filtrage par le chemin", 'cachelab_erreur');
return;
}
continue 2; // échec : passe à la clé suivante
default:
spip_log("Méthode '$methode_chemin' pas prévue pour le filtrage par le chemin", 'cachelab_erreur');
return null;
};
}
@ -227,49 +240,58 @@ global $Memoization;
global $Memoization;
$data = $Memoization->get(substr($cle, $len_prefix));
if (!$data or !is_array($data)) {
spip_log ("clé=$cle : data est vide ou n'est pas un tableau : ".print_r($data,1), 'cachelab_erreur');
spip_log("clé=$cle : data est vide ou n'est pas un tableau : ".print_r($data, 1), 'cachelab_erreur');
continue;
};
};
// 3eme filtre : par une valeur dans l'environnement
if ($cle_objet
and (!isset ($data['contexte'][$cle_objet])
or ($data['contexte'][$cle_objet]!=$id_objet)))
and (!isset($data['contexte'][$cle_objet])
or ($data['contexte'][$cle_objet]!=$id_objet))) {
continue;
}
// 4eme filtre : par une extension
if ($plusfunc
and !$plusfunc ($action, $conditions, $options, $cle, $data, $stats))
and !$plusfunc($action, $conditions, $options, $cle, $data, $stats)) {
continue;
}
// restent les cibles
$stats['nb_cible']++;
if ($do_lists)
if ($do_lists) {
$stats['l_cible'][] = $cle;
}
cachelab_appliquer ($action, $cle, $data, $options, $return);
cachelab_appliquer($action, $cle, $data, $options, $return);
if ($return
and (($action=='get')
or (substr($action,0,4)=='get_')))
if ($return
and (($action=='get')
or (substr($action, 0, 4)=='get_'))) {
return $return; // TODO chrono aussi dans ce cas
}
}
$stats['chrono'] = microtime_do ('end', 'ms');
$msg = "cachelab_cibler($action) en {$stats['chrono']} ms ({$stats['nb_cible']} caches sur {$stats['nb_candidats']})"
$stats['chrono'] = microtime_do('end', 'ms');
$msg = "cachelab_cibler($action) en {$stats['chrono']}ms ({$stats['nb_cible']} caches sur {$stats['nb_candidats']})"
."\n".print_r($conditions, 1);
if (count($options))
if (count($options)) {
$msg .= "\n".print_r($options, 1);
if (defined ('LOG_CACHELAB_CHRONO') and LOG_CACHELAB_CHRONO)
spip_log ($msg, 'cachelab_chrono.'._LOG_INFO);
if (defined ('LOG_CACHELAB_SLOW') and ($stats['chrono'] > LOG_CACHELAB_SLOW))
spip_log ($msg, 'cachelab_slow.'._LOG_INFO_IMPORTANTE);
if (($action=='del') and defined ('LOG_CACHELAB_TOOMANY_DEL') and ($stats['nb_cible'] > LOG_CACHELAB_TOOMANY_DEL))
spip_log ($msg, 'cachelab_toomany_del.'._LOG_INFO_IMPORTANTE);
if ($return)
}
if (defined('LOG_CACHELAB_CHRONO') and LOG_CACHELAB_CHRONO) {
spip_log($msg, 'cachelab_chrono.'._LOG_INFO);
}
if (defined('LOG_CACHELAB_SLOW') and ($stats['chrono'] > LOG_CACHELAB_SLOW)) {
spip_log($msg, 'cachelab_slow.'._LOG_INFO_IMPORTANTE);
}
if (($action=='del') and defined('LOG_CACHELAB_TOOMANY_DEL') and ($stats['nb_cible'] > LOG_CACHELAB_TOOMANY_DEL)) {
spip_log($msg, 'cachelab_toomany_del.'._LOG_INFO_IMPORTANTE);
}
if ($return) {
$stats['val'] = $return;
}
return $stats;
}
@ -277,30 +299,31 @@ global $Memoization;
* @param $action
* @param array $objets_invalidants
*/
function controler_invalideur($action, $objets_invalidants=array()) {
function controler_invalideur($action, $objets_invalidants = array()) {
static $prev_derniere_modif_invalide;
switch($action) {
case 'stop' :
switch ($action) {
case 'stop':
$objets_invalidants = array();
// nobreak;
case 'select' :
case 'select':
$prev_derniere_modif_invalide = $GLOBALS['derniere_modif_invalide'];
if (is_array($objets_invalidants))
if (is_array($objets_invalidants)) {
$GLOBALS['derniere_modif_invalide'] = $objets_invalidants;
break;
case 'go' :
}
break;
case 'go':
$GLOBALS['derniere_modif_invalide'] = $prev_derniere_modif_invalide;
break;
break;
}
}
//
// Exemple d'extension utilisable avec 'plus'=>'contexte'
// Filtrer non sur une seule valeur de l'environnement comme avec 'cle_objet'
// mais sur un ensemble de valeurs spécifié par $conditions['contexte']
// mais sur un ensemble de valeurs spécifié par $conditions['contexte']
// qui est un tableau de (clé, valeur)
// Toutes les valeurs doivent être vérifiées dans l'environnement.
//
//
/**
* @param $action
* @param $conditions
@ -311,10 +334,11 @@ static $prev_derniere_modif_invalide;
* @return bool
*/
function cachelab_ciblercache_contexte($action, $conditions, $options, $cle, &$data, &$stats) {
if (!isset ($data['contexte'])
if (!isset($data['contexte'])
or !isset($conditions['contexte'])
or !is_array($conditions['contexte']))
or !is_array($conditions['contexte'])) {
return false;
}
$diff = array_diff_assoc($conditions['contexte'], $data['contexte']);
return empty($diff);
}

89
inc/cachelab_invalideur.php

@ -9,11 +9,13 @@ if (!defined('_ECRIRE_INC_VERSION')) {
}
include_spip('inc/cachelab_utils');
if (!defined('LOG_BALISECACHE_FILTRES'))
if (!defined('LOG_BALISECACHE_FILTRES')) {
define('LOG_BALISECACHE_FILTRES', 'oui');
}
if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES'))
if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES')) {
define('LOG_BALISECACHE_DUREES_DYNAMIQUES', false);
}
/**
@ -26,7 +28,7 @@ if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES'))
* pour le type d'objet en question (non utilisé cependant) et pour
* tout le site (sur la meta `derniere_modif`)
*
* @global derniere_modif_invalide
* @global bool|array derniere_modif_invalide
* Par défaut à `true`, la meta `derniere_modif` est systématiquement
* calculée dès qu'un invalideur se présente. Cette globale peut
* être mise à `false` (aucun changement sur `derniere_modif`) ou
@ -54,19 +56,19 @@ function suivre_invalideur($cond, $modif = true) {
// stocker la date_modif_extra_$extra (ne sert a rien)
ecrire_meta('derniere_modif_extra_' . $r[1], time());
$f="cachelab_suivre_invalideur_{$r[1]}";
}
else {
} else {
// stocker la date_modif_$objet (ne sert a rien)
ecrire_meta('derniere_modif_' . $objet, time());
$f="cachelab_suivre_invalideur_$objet";
}
if (function_exists($f)) {
spip_log ("suivre_invalideur appelle $f($cond,$modif)", "cachelab");
spip_log("suivre_invalideur appelle $f($cond,$modif)", 'cachelab');
$modif = $f($cond, $modif); // $f renvoie la nouvelle valeur de $modif
// si l'invalidation a été totalement traitée par $f, ya plus rien à faire
if (!$modif)
if (!$modif) {
return;
}
}
}
@ -77,11 +79,11 @@ function suivre_invalideur($cond, $modif = true) {
or ($objet
and in_array($objet, $GLOBALS['derniere_modif_invalide']))) {
ecrire_meta('derniere_modif', time());
include_spip ('inc/cachelab');
spip_log ("invalidation totale / signal '$cond' avec objet '$objet'", "suivre_invalideur");
include_spip('inc/cachelab');
spip_log("invalidation totale / signal '$cond' avec objet '$objet'", 'suivre_invalideur');
} else {
spip_log("invalidation totale évitée : $cond", 'cachelab_effondrement_evite');
}
else
spip_log ("invalidation totale évitée : $cond", "cachelab_effondrement_evite");
}
//
@ -89,13 +91,13 @@ function suivre_invalideur($cond, $modif = true) {
// le core indique : "Calcul des pages : noter dans la base les liens d'invalidation"
//
// Appelé à la fin de creer_cache
// $page est le tableau décrivant le cache qui vient d'être calculé
// avec les clés suivantes pour ses métadonnées :
// $page est le tableau décrivant le cache qui vient d'être calculé
// avec les clés suivantes pour ses métadonnées :
// squelette,source,process_ins,invalideurs,entetes,duree,texte,notes,contexte,lastmodified,sig
// http://code.spip.net/@maj_invalideurs
//
// S'il y a une entete X-Spip-Methode-Duree-Cache on récupère la méthode
// et on appelle la fonction cachelab_calcule_duree_cache_lamethode
// et on appelle la fonction cachelab_calcule_duree_cache_lamethode
// avec en argument la valeur de l'argument dans l'envt ou de date_creation par défaut
// On corrige alors la durée du cache avec la valeur retournée.
//
@ -107,22 +109,24 @@ function suivre_invalideur($cond, $modif = true) {
// define ('LOG_INVALIDATION_CORE', true);
function maj_invalideurs($fichier, &$page) {
global $Memoization;
// Rq : ici, le texte du cache est non zipé (cf function creer_cache dans memoization),
// Rq : ici, le texte du cache est non zipé (cf function creer_cache dans memoization),
// tandis que la version en cache peut être zipée (avec index 'gz').
if (LOG_INVALIDATION_CORE) {
if (LOG_INVALIDATION_CORE) {
// Abondamment appelé. À part pour pas noyer les autres
spip_log ("maj_invalideurs($fichier, &page)", "invalideur_core_maj_invalideurs");
spip_log ("maj_invalideurs($fichier, &page)\n".print_r($page,1), "invalideur_core_maj_invalideurs_details");
spip_log("maj_invalideurs($fichier, &page)", 'invalideur_core_maj_invalideurs');
spip_log("maj_invalideurs($fichier, &page)\n".print_r($page, 1), 'invalideur_core_maj_invalideurs_details');
};
static $var_cache;
$infos = $hint_squel = '';
if (!isset($var_cache))
if (!isset($var_cache)) {
$var_cache = _request('var_cache');
if ($var_cache=='sessionnement') // on veut le sessionnement seul à l'écran
}
if ($var_cache=='sessionnement') { // on veut le sessionnement seul à l'écran
$hint_squel = ' title="'.attribut_html($page['source']).'" ';
else
} else {
$infos = $page['source']; // on prépare les infos supplémentaires
}
// Pour le calcul dynamique d'une durée de cache, la fonction user
// reçoit la *valeur* de l'une des valeurs de l'environnement (par défaut "date_creation")
@ -132,16 +136,18 @@ static $var_cache;
list ($f, $arg) = split_first_arg($f, 'date_creation');
if (function_exists($f)) {
if (!isset($page['contexte'][$arg])) {
spip_log ("#CACHE avec squelette {$page['source']} et calcul de durée avec $f mais pas de '$arg' dans le contexte ".print_r($page['contexte'],1), "cachelab_erreur");
spip_log("#CACHE avec squelette {$page['source']} et calcul de durée avec $f mais pas de '$arg' dans le contexte ".print_r($page['contexte'], 1), 'cachelab_erreur');
return;
}
$duree = $f($page['contexte'][$arg],$page);
$duree = $f($page['contexte'][$arg], $page);
if (!is_null($duree)) {
if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES)
spip_log ("#CACHE $f (arg={$page['contexte'][$arg]}) renvoie : $duree s", 'balisecache_duree_dynamique');
if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES) {
spip_log("#CACHE $f (arg={$page['contexte'][$arg]}) renvoie : $duree s", 'balisecache_duree_dynamique');
}
if ($var_cache)
if ($var_cache) {
echo "<div class='cachelab_blocs' $hint_squel><h6>Durée dynamique : $duree</h6><small>$infos</small></div>";
}
$page['duree'] = $duree;
$page['entetes']['X-Spip-Cache']=$duree;
@ -156,23 +162,25 @@ static $var_cache;
// sur le cache quand la base de donnees est plantée (à tester)"
$Memoization->set($fichier, $page, 3600+$duree);
}
} else {
spip_log("#CACHE duree cache : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page, 1), 'cachelab_erreur');
}
else
spip_log ("#CACHE duree cache : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page,1), "cachelab_erreur");
}
// Exemple : <INCLURE{fond=mes_scores,duree-cache=#GET{duree_sicestmoi_oupas}}/>
if (isset($page['contexte']['duree-cache'])) {
if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES)
spip_log ("Pour $fichier, contexte[duree-cache]={$page['contexte']['duree-cache']}", 'balisecache_duree_dynamique');
if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES) {
spip_log("Pour $fichier, contexte[duree-cache]={$page['contexte']['duree-cache']}", 'balisecache_duree_dynamique');
}
if ($var_cache)
if ($var_cache) {
echo "<div class='cachelab_blocs' $hint_squel><h6>Contexte duree-cache : $duree</h6><small>$infos</small></div>";
}
$page['entetes']['X-Spip-Cache']
= $page['entetes']['X-Spip-Contexte-Duree-Cache']
= $page['duree']
= $duree
= $page['duree']
= $duree
= intval($page['contexte']['duree-cache']);
// (idem : creer_cache appelle maj_invalideurs *aprés* d'avoir écrit le cache)
@ -187,19 +195,22 @@ static $var_cache;
$f = 'cachelab_filtre_'.$page['entetes']['X-Spip-Filtre-Cache'];
list ($f, $arg) = split_first_arg($f);
if (function_exists($f)) {
if (!defined('LOG_BALISECACHE_FILTRES') or LOG_CACHELAB_FILTRES)
spip_log ("#CACHE appelle le filtre $f ($arg)", 'balisecache_filtres');
if (!defined('LOG_BALISECACHE_FILTRES') or LOG_BALISECACHE_FILTRES) {
spip_log("#CACHE appelle le filtre $f ($arg)", 'balisecache_filtres');
}
$toset = $f($page, $arg);
// Le filtre renvoie un booléen qui indique s'il faut mémoizer le cache
if ($toset)
if ($toset) {
$Memoization->set($fichier, $page, $page['entete']['X-Spip-Cache']);
}
} else {
spip_log("#CACHE filtre : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page, 1), 'cachelab_erreur');
}
else
spip_log ("#CACHE filtre : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page,1), "cachelab_erreur");
}
if ($var_cache)
if ($var_cache) {
echo '<div class="cachelab_blocs" '.$hint_squel.'><h6>Sessionnement : '
.cachelab_etat_sessionnement($page['invalideurs'], 'précis')
.'</h6><small>'.$infos.'</small></div>';
}
}

32
inc/cachelab_utils.php

@ -6,7 +6,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
//
// sépare à la lisp le premier mot et les autres
//
//
// $f (string) : liste à séparer
// $cdr (string ou array) : valeur par défaut pour le 2eme élt renvoyé
// $string_wanted (bool) : type du 2eme élément renvoyé
@ -15,36 +15,37 @@ if (!defined('_ECRIRE_INC_VERSION')) {
// retour[0] (string) : 1er élément de la liste
// retour[1] (string ou array selon $string_wanted) : reste de la liste
//
function split_first_arg($l, $cdr='', $string_wanted=true) {
function split_first_arg($l, $cdr = '', $string_wanted = true) {
$l = preg_replace('/\s+/', ' ', trim($l), -1, $n);
$lparts = explode(' ', $l);
if ($lparts != array_filter($lparts)) {
spip_log ("split_first_arg($l, $cdr, $string_wanted); mauvais format du 1er argument".print_r($lparts,1), "cachelab_ASSERT");
exit;
spip_log("split_first_arg($l, $cdr, $string_wanted); mauvais format du 1er argument".print_r($lparts, 1), 'cachelab_ASSERT');
exit;
}
$car = array_shift($lparts);
if (!$car) {
spip_log ("split_first_arg($l,$cdr,$string_wanted) : pb avec le 1er argument, reste lparts=".print_r($lparts,1), "cachelab_ASSERT");
exit;
spip_log("split_first_arg($l,$cdr,$string_wanted) : pb avec le 1er argument, reste lparts=".print_r($lparts, 1), 'cachelab_ASSERT');
exit;
}
if ($lparts) {
if ($string_wanted)
$cdr = implode(' ', $lparts);
else
$cdr = $lparts;
if ($string_wanted) {
$cdr = implode(' ', $lparts);
} else {
$cdr = $lparts;
}
}
return array ($car, $cdr);
}
function split_f_arg($f, $arg='') {
spip_log("split_f_arg($f, $arg", "cachelab_OBSOLETE");
return split_first_arg ($f, $arg);
function split_f_arg($f, $arg = '') {
spip_log("split_f_arg($f, $arg", 'cachelab_OBSOLETE');
return split_first_arg($f, $arg);
}
function slug_chemin($chemin, $sep='_') {
return str_replace ('/', $sep, $chemin);
function slug_chemin($chemin, $sep = '_') {
return str_replace('/', $sep, $chemin);
}
if (!function_exists('plugin_est_actif')) {
@ -53,4 +54,3 @@ if (!function_exists('plugin_est_actif')) {
return $f($prefixe, 'est_actif');
}
}

70
inc/invalideur.php

@ -92,9 +92,9 @@ function taille_du_cache() {
$time = isset($GLOBALS['meta']['cache_mark']) ? $GLOBALS['meta']['cache_mark'] : 0;
for ($i=0; $i < 256; $i++) {
$dir = _DIR_CACHE.sprintf('%02s', dechex($i));
if (@is_dir($dir) AND is_readable($dir) AND $d = @opendir($dir)) {
if (@is_dir($dir) and is_readable($dir) and $d = @opendir($dir)) {
while (($f = readdir($d)) !== false) {
if (preg_match(',^[[0-9a-f]+\.cache$,S', $f) AND $a = stat("$dir/$f")) {
if (preg_match(',^[[0-9a-f]+\.cache$,S', $f) and $a = stat("$dir/$f")) {
$n++;
if ($a['mtime'] >= $time) {
if ($a['blocks'] > 0) {
@ -134,7 +134,10 @@ function taille_du_cache() {
* Nombre de fichiers supprimés
**/
function purger_repertoire($dir, $options = array()) {
$handle = @opendir($dir);
if (!is_dir($dir) or !is_readable($dir)) {
return;
}
$handle = opendir($dir);
if (!$handle) {
return;
}
@ -157,8 +160,8 @@ function purger_repertoire($dir, $options = array()) {
} else {
if (is_dir($chemin)) {
$opts = $options;
if (isset($otpions['limit'])) {
$otps['limit'] = $otpions['limit'] - $total;
if (isset($options['limit'])) {
$opts ['limit'] = $options['limit'] - $total;
}
$total += purger_repertoire($chemin, $opts);
if (isset($options['subdir']) && $options['subdir']) {
@ -195,9 +198,10 @@ function appliquer_quota_cache() {
$dir = sous_repertoire(_DIR_CACHE, $l);
list($nombre, $taille) = nombre_de_fichiers_repertoire($dir);
$total_cache = $taille * $nombre;
if ($total_cache) // Ajout / core car c'est vide avec la memoization
if ($total_cache) { // Ajout / core car c'est vide avec la memoization
spip_log("Taille du CACHE estimee ($l): "
. (intval(16 * $total_cache / (1024 * 1024 / 10)) / 10) . " Mo", "invalideur");
. (intval(16 * $total_cache / (1024 * 1024 / 10)) / 10) . ' Mo', 'invalideur');
}
// Nombre max de fichiers a supprimer
if ($GLOBALS['quota_cache'] > 0
@ -206,16 +210,17 @@ function appliquer_quota_cache() {
$trop = $total_cache - ($GLOBALS['quota_cache'] / 16) * 1024 * 1024;
$trop = 3 * intval($trop / $taille);
if ($trop > 0) {
$n = purger_repertoire($dir,
$n = purger_repertoire(
$dir,
array(
'atime' => time() - _AGE_CACHE_ATIME,
'limit' => $trop,
'subdir' => true // supprimer les vieux sous repertoire de session (avant [15851])
)
);
spip_log("$dir : $n/$trop caches supprimes [taille moyenne $taille]", "invalideur");
spip_log("$dir : $n/$trop caches supprimes [taille moyenne $taille]", 'invalideur');
$total_cache = intval(max(0, (16 * $total_cache) - $n * $taille) / (1024 * 1024) * 10) / 10;
spip_log("cache restant estime : $total_cache Mo, ratio " . $total_cache / $GLOBALS['quota_cache'], "invalideur");
spip_log("cache restant estime : $total_cache Mo, ratio " . $total_cache / $GLOBALS['quota_cache'], 'invalideur');
// redemander la main pour eviter que le cache ne gonfle trop
// mais pas si on ne peut pas purger car les fichiers sont trops recents
@ -224,7 +229,7 @@ function appliquer_quota_cache() {
and $n * 50 > $trop
) {
$encore = true;
spip_log("Il faut encore purger", "invalideur");
spip_log('Il faut encore purger', 'invalideur');
}
}
}
@ -241,8 +246,9 @@ function appliquer_quota_cache() {
function retire_cache($cache) {
if (preg_match(
"|^([0-9a-f]/)?([0-9]+/)?[0-9a-f]+\.cache(\.gz)?$|i",
$cache)) {
'|^([0-9a-f]/)?([0-9]+/)?[0-9a-f]+\.cache(\.gz)?$|i',
$cache
)) {
// supprimer le fichier (de facon propre)
supprimer_fichier(_DIR_CACHE . $cache);
} else {
@ -257,8 +263,9 @@ function retire_cache($cache) {
## mais ici elles ne font plus rien
##
if (!defined('LOG_INVALIDATION_CORE'))
define ('LOG_INVALIDATION_CORE', false);
if (!defined('LOG_INVALIDATION_CORE')) {
define('LOG_INVALIDATION_CORE', false);
}
// Supprimer les caches marques "x"
// A priori dans cette version la fonction ne sera pas appelee, car
@ -267,11 +274,13 @@ if (!defined('LOG_INVALIDATION_CORE'))
function retire_caches($chemin = '') {
if (isset($GLOBALS['meta']['invalider_caches'])) {
effacer_meta('invalider_caches');
if (LOG_INVALIDATION_CORE)
spip_log ("retire_caches($chemin = '') ne devrait pas être appelé car ['meta']['invalider_caches'] devrait être false", "invalideur_core_retire_caches_BUG");
if (LOG_INVALIDATION_CORE) {
spip_log("retire_caches($chemin = '') ne devrait pas être appelé car ['meta']['invalider_caches'] devrait être false", 'invalideur_core_retire_caches_BUG');
}
} # concurrence
if (LOG_INVALIDATION_CORE)
spip_log ("retire_caches($chemin = '')", "invalideur_core_retire_caches");
if (LOG_INVALIDATION_CORE) {
spip_log("retire_caches($chemin = '')", 'invalideur_core_retire_caches');
}
}
@ -286,18 +295,20 @@ function calcul_invalideurs($corps, $primary, &$boucles, $id_boucle) {
// invoquee quand on vide tout le cache en bloc (action/purger)
//
// http://code.spip.net/@supprime_invalideurs
function supprime_invalideurs() {
if (LOG_INVALIDATION_CORE)
spip_log ("supprime_invalideurs()", "invalideur_core");
function supprime_invalideurs() {
if (LOG_INVALIDATION_CORE) {
spip_log('supprime_invalideurs()', 'invalideur_core');
}
}
// les invalideurs sont en général de la forme "objet/id_objet"
// http://code.spip.net/@insere_invalideur
// JAMAIS appelé par le noyau,
// JAMAIS appelé par le noyau,
// ÉTAIT un hook post maj_invalideurs appelé avec $page['invalideurs'] et $fichier
function insere_invalideur($inval, $fichier) {
if (LOG_INVALIDATION_CORE)
spip_log ("insere_invalideur($inval, $fichier)", "invalideur_core");
function insere_invalideur($inval, $fichier) {
if (LOG_INVALIDATION_CORE) {
spip_log("insere_invalideur($inval, $fichier)", 'invalideur_core');
}
}
//
@ -306,7 +317,8 @@ function insere_invalideur($inval, $fichier) {
// http://code.spip.net/@applique_invalideur
// JAMAIS appelé par le noyau
// ÉTAIT un hook post suivre_invalideur avec la liste calculée des fichiers caches à invalider
function applique_invalideur($depart) {
if (LOG_INVALIDATION_CORE)
spip_log ("applique_invalideur($depart)", "invalideur_core");
function applique_invalideur($depart) {
if (LOG_INVALIDATION_CORE) {
spip_log("applique_invalideur($depart)", 'invalideur_core');
}
}

55
lib/microtime.inc.php

@ -2,56 +2,59 @@
//
// Chronométrage des appels php
function eleg_microtime($time, $unit='') {
function eleg_microtime($time, $unit = '') {
$time = round($time, 6);
switch ($unit) {
case 'ms' :
return ($time*1000).' ms';
case 'us' :
case 'µs' :
return ($time*1000000).' µs';
case 's' : nobreak;
return $time.'s';
case '' :
return $time;
case 'ms':
return ($time*1000).' ms';
case 'us':
case 'µs':
return ($time*1000000).' µs';
case 's':
nobreak;
return $time.'s';
case '':
return $time;
}
spip_log('mauvais parametre unit pour eleg_microtime', 'erreur_microtime');
return '';
}
// microtime_do reçoit des commandes et l'unité d'affichage us, ms ou s
// begin : reset
// now : microtime depuis init
// end : now + begin
// last : microtime depuis le dernier appel, sauf now
function microtime_do ($command, $unit='') {
function microtime_do($command, $unit = '') {
static $u_init = 0;
static $s_init = 0;
static $u_last = 0;
static $s_last = 0;
switch ($command) {
case 'begin' :
case 'init' :
case 'begin':
case 'init':
list ($u_last, $s_last) = list ($u_init, $s_init) = explode(' ', microtime());
return 0;
return 0;
case 'now' :
list ($u_last, $s_last) = explode(' ', microtime());
return eleg_microtime(($s_last - $s_init)+($u_last - $u_init), $unit);
case 'now':
list ($u_last, $s_last) = explode(' ', microtime());
return eleg_microtime(($s_last - $s_init)+($u_last - $u_init), $unit);
case 'end' :
list ($u_last, $s_last) = explode(' ', microtime());
case 'end':
list ($u_last, $s_last) = explode(' ', microtime());
$res = ($s_last - $s_init)+($u_last - $u_init);
$u_init = $u_last;
$s_init = $s_last;
return eleg_microtime($res, $unit);
return eleg_microtime($res, $unit);
case 'last' :
list ($u_now, $s_now) = explode(' ', microtime());
case 'last':
list ($u_now, $s_now) = explode(' ', microtime());
$res = ($s_now - $s_last)+($u_now - $u_last);
$u_last = $u_now;
$s_last = $s_now;
return eleg_microtime($res, $unit);
return eleg_microtime($res, $unit);
default :
die ("unknown microtime_do command « $command »");
};
default:
die("unknown microtime_do command « $command »");
}
};

6
paquet.xml

@ -1,14 +1,14 @@
<paquet
prefix="cachelab"
categorie="outil"
version="0.99.0"
categorie="performance"
version="0.99.1"
etat="dev"
compatibilite="[3.0.0;3.3.*]"
logo="images/cachelab-32.png"
documentation="https://contrib.spip.net/5033"
>
<nom>CacheLab</nom>
<!-- Invalidation ciblée et autres actions sur des caches APC filtrés des squelettes SPIP -->
<!-- Invalidation ciblée et autres actions sur les caches APC filtrés des squelettes SPIP -->
<auteur lien="https://contrib.spip.net/JLuc">JLuc</auteur>
<credit lien="https://thenounproject.com/term/lab/1796357/">Icone de Nawicon Studio, Licence Creative Commons</credit>

163
public/cachelab_balises.php

@ -15,10 +15,10 @@ include_spip('inc/cachelab_utils');
* - `cache-client` autorise gestion du IF_MODIFIED_SINCE
* - `statique` ne respecte pas l'invalidation par modif de la base
* (mais s'invalide tout de même à l'expiration du delai)
* - `calcul-methode` où la partie `methode` est variable et indique
* la méthode de calcul dynamique de la durée cache à partir
* - `calcul-methode` où la partie `methode` est variable et indique
* la méthode de calcul dynamique de la durée cache à partir
* de son contenu yc ses métadonnées et notamment l'env
* Dans ce cas le 1er argument sert seulement pour compatibilité
* Dans ce cas le 1er argument sert seulement pour compatibilité
* si on désactive cachelab
*
* @balise
@ -41,7 +41,7 @@ include_spip('inc/cachelab_utils');
* #CACHE{log,session anonyme}
* ```
* @note
* En absence de durée indiquée par cette balise,
* En absence de durée indiquée par cette balise,
* la durée du cache est donnée
* par la constante `_DUREE_CACHE_DEFAUT`
*
@ -50,7 +50,7 @@ include_spip('inc/cachelab_utils');
* @return Champ
* Pile complétée par le code à générer
**/
function balise_CACHE ($p) {
function balise_CACHE($p) {
if ($p->param) {
$i = 0;
@ -110,36 +110,36 @@ function balise_CACHE ($p) {
$methode = substr($pa, 6);
$ajout = "'<'.'" . '?php header("X-Spip-Methode-Duree-Cache: '.$methode.'"); ?' . "'.'>'";
$code .= $concat.$ajout;
spip_log ("#CACHE($pa) sur $sourcefile avec méthode de calcul de la durée du cache : $methode", 'cachelab_OBSOLETE');
spip_log("#CACHE($pa) sur $sourcefile avec méthode de calcul de la durée du cache : $methode", 'cachelab_OBSOLETE');
}
if (strpos($pa, 'filtre-')===0) {
$methode = substr($pa, 7);
$methode = substr($pa, 7);
$ajout = "'<'.'" . '?php header("X-Spip-Filtre-Cache: '.$methode.'"); ?' . "'.'>'";
$code .= $concat.$ajout;
spip_log ("#CACHE($pa) sur $sourcefile avec filtre sur le cache complet : $methode", 'cachelab_OBSOLETE');
$code .= $concat.$ajout;
spip_log("#CACHE($pa) sur $sourcefile avec filtre sur le cache complet : $methode", 'cachelab_OBSOLETE');
}
// fin des syntaxes obsolètes
list ($func, $args) = split_first_arg ($pa);
list ($func, $args) = split_first_arg($pa);
switch ($func) {
// TODO : également traiter ici les morceaux du core traités plus haut
case 'statique' :
case 'duree' :
case 'statique':
case 'duree':
$ajout = "'<'.'" . "?php header(\"X-Spip-Methode-Duree-Cache: $args\"); ?" . "'.'>'";
$code .= $concat.$ajout;
spip_log ("#CACHE{$pa} sur $sourcefile avec méthode de calcul de la durée du cache : $args", 'cachelab');
break;
spip_log("#CACHE{$pa} sur $sourcefile avec méthode de calcul de la durée du cache : $args", 'cachelab');
break;
case 'log' :
case 'session' :
case 'filtre' :
case 'log':
case 'session':
case 'filtre':
$ajout = "'<'.'" . '?php header("X-Spip-Filtre-Cache: '.$pa.'"); ?' . "'.'>'";
$code .= $concat.$ajout;
spip_log ("#CACHE{$pa} sur $sourcefile : filtre $func($args) sur le cache complet", 'cachelab');
break;
default :
break;
$code .= $concat.$ajout;
spip_log("#CACHE{$pa} sur $sourcefile : filtre $func($args) sur le cache complet", 'cachelab');
break;
default:
break;
}
}
} else {
@ -153,7 +153,7 @@ function balise_CACHE ($p) {
//
// Calcul de durée de cache dynamique progressive
// Calcul de durée de cache dynamique progressive
// adapté pour un affichage approximatif et habituel
// du type "il y a 20 secondes", "il y a 3 minutes", "ce matin",
// "hier soir", "la semaine dernière" ou "il y a 3 mois"
@ -168,30 +168,41 @@ function balise_CACHE ($p) {
//
function cachelab_duree_progapprox($date_creation) {
$dt_creation = new DateTime($date_creation);
if (!$dt_creation)
if (!$dt_creation) {
return _DUREE_CACHE_DEFAUT;
}
$interval = $dt_creation->diff(new DateTime('NOW'),true); // valeur absolue
if (!$interval)
$interval = $dt_creation->diff(new DateTime('NOW'), true); // valeur absolue
if (!$interval) {
return _DUREE_CACHE_DEFAUT;
if ($interval->y > 2)
}
if ($interval->y > 2) {
return 6*30*24*3600; // 6 mois si plus de 2 ans
if ($interval->y)
}
if ($interval->y) {
return 30*24*3600; // 1 mois si plus d'un an
if ($interval->m)
}
if ($interval->m) {
return 7*24*3600; // 1 semaine si plus d'un mois
if ($interval->d > 7)
}
if ($interval->d > 7) {
return 24*3600; // 1 jour si plus d'une semaine
if ($interval->d)
}
if ($interval->d) {
return 6*3600; // 6h si plus d'un jour
if ($interval->h > 6)
}
if ($interval->h > 6) {
return 3600; // 1h si plus de 6h
if ($interval->h)
}
if ($interval->h) {
return 30*60; // 1/2h si plus d'1h
if ($interval->i > 10)
}
if ($interval->i > 10) {
return 10*60; // 10 minutes si plus de 10 minutes
if ($interval->i)
}
if ($interval->i) {
return 60; // chaque minute si plus d'une minute
}
return 10; // 10secondes si moins d'une minute
}
@ -202,7 +213,7 @@ function cachelab_duree_progapprox($date_creation) {
* @return int : le nombre de secondes restant jusqu'au prochain minuit cinq
*/
function cachelab_duree_jusqueminuit($date_unused) {
return strtotime('tomorrow') + 300 - time();
return strtotime('tomorrow') + 300 - time();
}
//
@ -210,7 +221,7 @@ function cachelab_duree_jusqueminuit($date_unused) {
// dans un fichier de log dont le nom reprend le chemin du squelette
// (avec les / remplacés par des _)
//
// Exemples d'usages :
// Exemples d'usages :
// #CACHE{3600,log} : log tout le cache, méta et html
// #CACHE{log lastmodified} : log l'entrée lastmodified du cache
// #CACHE{log contexte} : log tout le tableau d'environnement
@ -218,24 +229,22 @@ function cachelab_duree_jusqueminuit($date_unused) {
//
function cachelab_filtre_log($cache, $arg) {
if (!is_array($cache) or !isset($cache['source']) or !isset($cache['lastmodified']) or !isset($cache['invalideurs'])) {
spip_log ("cachelab_duree_progapprox ne reçoit pas un cache mais".print_r($cache,1), "cachelab_assert");
spip_log('cachelab_duree_progapprox ne reçoit pas un cache mais'.print_r($cache, 1), 'cachelab_assert');
return null;
}
$source_limace = slug_chemin($cache['source']);
$arg=trim($arg);
if ($arg) {
if ($arg) {
if (strpos($arg, '/')) { #CACHE{log i/j}
$ij=explode('/',$arg);
$ij=explode('/', $arg);
$c = $cache[$i=trim(array_shift($ij))];
$c = $c[trim($j=array_shift($ij))];
}
else { #CACHE{log i}
$c = $c[trim($j = array_shift($ij))];
} else { #CACHE{log i}
$c = $cache[$arg];
}
} else { $c = $cache; #CACHE{log}
}
else
$c = $cache; #CACHE{log}
spip_log ("cache[$arg] : ".print_r($c,1), "cachelab_".$source_limace);
spip_log("cache[$arg] : ".print_r($c, 1), 'cachelab_'.$source_limace);
}
@ -255,15 +264,15 @@ function cachelab_filtre_log($cache, $arg) {
// #CACHE{session assert oui_login} s'assure que tous les emplois sont sessionnés avec un internaute identifié
// #CACHE{session assert oui_anonyme} s'assure que tous les emplois sont sessionnés avec un internaute identifié (inutile ?)
// #CACHE{session assert anonyme} s'assure que tous les emplois sans internaute identifié
//
//
// #CACHE{session log} loge l'état du sessionnement dans un cache dédié à ce squelette
// #CACHE{session insert} insère à la fin du cache l'affichage de l'état du sessionnement
// #CACHE{session echo} affiche l'état du sessionnement comme var_cache
// #CACHE{session echo} affiche l'état du sessionnement comme var_cache
// mais pour ce cache seulement et seulement pour les caches dynamiques
//
function cachelab_filtre_session (&$cache, $totarg) {
function cachelab_filtre_session(&$cache, $totarg) {
if (!is_array($cache) or !isset($cache['source']) or !isset($cache['lastmodified']) or !isset($cache['invalideurs'])) {
spip_log ("cachelab_filtre_assertsession ne reçoit pas un cache mais".print_r($cache,1), "cachelab_assert");
spip_log('cachelab_filtre_assertsession ne reçoit pas un cache mais'.print_r($cache, 1), 'cachelab_assert');
return null;
}
$source = $cache['source'];
@ -275,27 +284,27 @@ function cachelab_filtre_session (&$cache, $totarg) {
$sess = cachelab_etat_sessionnement($invalideurs, 'avec_details');
$avec_echo = false;
switch ($func) {
case 'assert_echo' :
case 'assert_echo':
$avec_echo = true;
case 'assert' :
switch($what) {
case 'oui_login' :
case 'oui_anonyme' :
case 'non' :
case 'assert':
switch ($what) {
case 'oui_login':
case 'oui_anonyme':
case 'non':
$ok = ($sess==$what);
break;
case 'anonyme' :
case 'anonyme':
$ok = empty($invalideurs['session']); // oui_anonyme ou non
break;
case 'oui' :
case 'oui':
$ok = isset($invalideurs['session']); // oui_anonyme ou oui_login
break;
default:
spip_log ("Erreur de syntaxe : '$what' incorrect dans #CACHE{session $totarg}, il faut oui, oui_login, oui_anonyme, non ou anonyme", 'cachelab_erreur');
spip_log("Erreur de syntaxe : '$what' incorrect dans #CACHE{session $totarg}, il faut oui, oui_login, oui_anonyme, non ou anonyme", 'cachelab_erreur');
break 2;
}
if (!$ok) {
spip_log ("$source : session n'est pas '$what'. invalideurs=".print_r($invalideurs,1), "cachelab_assertsession");
if (!$ok) {
spip_log("$source : session n'est pas '$what'. invalideurs=".print_r($invalideurs, 1), 'cachelab_assertsession');
if ($avec_echo) {
echo "<div class='cachelab_blocs cachelab_assert'>
<h6>Sessionnement $sess devrait être $what</h6>
@ -305,34 +314,36 @@ function cachelab_filtre_session (&$cache, $totarg) {
}
break;
case 'insert' :
case 'insert':
global $Memoization;
if (!isset($Memoization)) {
spip_log ("Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé", 'cachelab_erreur');
spip_log("Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé", 'cachelab_erreur');
echo "<div class='cachelab_blocs'><h6>Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé</h6></div>";
break;
}
$cache['texte'] .= '<'."?php echo '<div class=\"cachelab_blocs\"><h6>$source sessionné : $sess</h6></div>' ?>";
$cache['process_ins'] = 'php';
break;
case 'echo' :
break;
case 'echo':
echo "<div class='cachelab_blocs'><h6>$source sessionné : $sess</h6></div>";
break;
case 'log' :
spip_log ('session : '.$sess, 'cachelab_session_'.$source_limace);
break;
default :
spip_log ("Syntaxe incorrecte dans $source : $func inconnu dans #CACHE{session $totarg}", 'cachelab_erreur');
break;
break;
case 'log':
spip_log('session : '.$sess, 'cachelab_session_'.$source_limace);
break;
default:
spip_log("Syntaxe incorrecte dans $source : $func inconnu dans #CACHE{session $totarg}", 'cachelab_erreur');
break;
}
}
function cachelab_etat_sessionnement ($invalideurs, $detail=false) {
if (!isset($invalideurs['session']))
function cachelab_etat_sessionnement($invalideurs, $detail = false) {
if (!isset($invalideurs['session'])) {
return 'non';
if (!$detail)
}
if (!$detail) {
return 'oui';
elseif ($invalideurs['session'])
} elseif ($invalideurs['session']) {
return 'oui_login';
}
return 'oui_anonyme';
}

Loading…
Cancel
Save