Changeset 115426 in spip-zone for _plugins_/cachelab


Ignore:
Timestamp:
May 17, 2019, 8:30:52 PM (3 months ago)
Author:
jluc@…
Message:

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

Location:
_plugins_/cachelab/trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/cachelab/trunk/cachelab_fonctions.php

    r115319 r115426  
    11<?php
    2 if (!defined('_ECRIRE_INC_VERSION')) return;
     2if (!defined('_ECRIRE_INC_VERSION')) {
     3        return;
     4}
    35
    46include_spip('public/cachelab_balises');
    57
    68// loger tous les temps des ciblages
    7 if (!defined('LOG_CACHELAB_CHRONO'))
     9if (!defined('LOG_CACHELAB_CHRONO')) {
    810        define('LOG_CACHELAB_CHRONO', false);
     11}
    912
    1013// Seuil minimal des temps de ciblage à loger dans cachelab_slow (en ms)
    11 if (!defined('LOG_CACHELAB_SLOW'))
     14if (!defined('LOG_CACHELAB_SLOW')) {
    1215        define('LOG_CACHELAB_SLOW', 70);
     16}
    1317
    1418// Seuil minimal du nombre de caches invalidés en un seul ciblage pour le loger dans cachelab_toomany_del
    15 if (!defined('LOG_CACHELAB_TOOMANY_DEL'))
    16         define('LOG_CACHELAB_TOOMANY_DEL',100);
     19if (!defined('LOG_CACHELAB_TOOMANY_DEL')) {
     20        define('LOG_CACHELAB_TOOMANY_DEL', 100);
     21}
    1722
    1823/* Autres constantes utilisées-définies dans inc/cachelab_invalideur :
  • _plugins_/cachelab/trunk/cachelab_pipelines.php

    r112738 r115426  
    1717.cachelab_assert {background-color: orange}
    1818</style>\n";
    19     return $flux;
     19        return $flux;
    2020}
  • _plugins_/cachelab/trunk/inc/cachelab.php

    r115319 r115426  
    1717 * @return bool : indique si l'action a pu être appliquée ou non
    1818 */
    19 function cachelab_appliquer ($action, $cle, $data=null, $options='', &$return=null) {
     19function cachelab_appliquer($action, $cle, $data = null, $options = '', &$return = null) {
    2020global $Memoization;
    2121        if (!isset($Memoization) or !$Memoization) {
     
    2525
    2626static $len_prefix;
    27         if (!$len_prefix)
     27        if (!$len_prefix) {
    2828                $len_prefix = strlen(_CACHE_NAMESPACE);
     29        }
    2930        $joliecle = substr($cle, $len_prefix);
    3031
    3132        switch ($action) {
    32         case 'del' :
     33        case 'del':
    3334                $del = $Memoization->del($joliecle);
    3435                if (!$del) {
    35                         spip_log ("Échec 'del' $joliecle", 'cachelab_erreur');
     36                        spip_log("Échec 'del' $joliecle", 'cachelab_erreur');
    3637                        return false;
    3738                };
    38                 break;
     39                        break;
    3940
    4041        // gérés par cachelab_cibler
    41         case 'pass' :   // passe
    42         case 'list' :   // renvoie les clés
    43         case 'clean' :  // nettoie
    44                 break;
     42        case 'pass':    // passe
     43        case 'list':    // renvoie les clés
     44        case 'clean':   // nettoie
     45                        break;
    4546               
    46         case 'list_html' :      // renvoie les contenus indexés par les clés sans préfixes
     47        case 'list_html':       // renvoie les contenus indexés par les clés sans préfixes
    4748                                                // attention ça peut grossir !
    48                 if (!is_array($return))
     49                if (!is_array($return)) {
    4950                        $return = array();
     51                }
    5052                $return[$joliecle] = $data['texte'];
    51                 break;
    52 
    53         case 'get' :    // renvoie le 1er cache ciblé
    54                 if (!$data)
     53                        break;
     54
     55        case 'get':     // renvoie le 1er cache ciblé
     56                if (!$data) {
    5557                        $data = $Memoization->get($joliecle);
     58                }
    5659                $return = $data;
    57                 break;
    58 
    59         case 'get_html' :       // renvoie le contenu du 1er cache
    60                 if (!$data)
     60                        break;
     61
     62        case 'get_html':        // renvoie le contenu du 1er cache
     63                if (!$data) {
    6164                        $data = $Memoization->get($joliecle);
     65                }
    6266                $return = $data['texte'];
    63                 break;
    64 
    65         default :
     67                        break;
     68
     69        default:
    6670                $f = 'cachelab_appliquer_'.$action;
    67                 if (function_exists($f))
     71                if (function_exists($f)) {
    6872                        return $f($action, $cle, $data, $options, $return);
    69                 else {
    70                         spip_log ("L'action $action n'est pas définie pour cachelab_applique", 'cachelab_erreur');
     73                } else {
     74                        spip_log("L'action $action n'est pas définie pour cachelab_applique", 'cachelab_erreur');
    7175                        return false;
    72                 };
     76                }
    7377        }
    7478        return true;
     
    8993 *
    9094 */
    91 function cachelab_cibler ($action, $conditions=array(), $options=array()) {
     95function cachelab_cibler($action, $conditions = array(), $options = array()) {
    9296global $Memoization;
    9397        if (!isset($Memoization) or !$Memoization or !in_array($Memoization->methode(), array('apc', 'apcu'))) {
    94                 spip_log("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu", 'cachelab_erreur');
    95                 die ("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu");
     98                spip_log("cachelab_cibler($action...) : Mémoization n'est pas activé avec APC ou APCu", 'cachelab_erreur');
     99                die("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu");
    96100        }
    97101        $return = null;
     
    99103        // filtrage
    100104        $session = (isset($conditions['session']) ? $conditions['session'] : null);
    101         if ($session=='courante')
     105        if ($session=='courante') {
    102106                $session = spip_session();
     107        }
    103108
    104109        $chemin = (isset($conditions['chemin']) ? $conditions['chemin'] : null);
     
    108113        $id_objet = (isset($conditions['id_objet']) ? $conditions['id_objet'] : null);
    109114        if ($cle_objet and !$id_objet) {
    110                 spip_log("cachelab_cibler : $cle_objet inconnu\n".print_r(debug_backtrace(),1), "cachelab_erreur");
     115                spip_log("cachelab_cibler : $cle_objet inconnu\n".print_r(debug_backtrace(), 1), 'cachelab_erreur');
    111116                $cle_objet=null;
    112117        }
    113118
    114119        // pour 'contexte' on simule un 'plus' pour donner un exemple d'extension
    115         if (isset($conditions['contexte']) and $conditions['contexte'] and !isset($conditions['plus']))
     120        if (isset($conditions['contexte']) and $conditions['contexte'] and !isset($conditions['plus'])) {
    116121                $conditions['plus'] = 'contexte';
     122        }
    117123        if ($plus = (isset($conditions['plus']) ? (string)$conditions['plus'] : '')) {
    118124                $plusfunc='cachelab_ciblercache_'.$plus;
    119125                // Signature nécessaire : $plusfunc ($action, $conditions, $options, &$stats)
    120126                if (!function_exists($plusfunc)) {
    121                         spip_log ("La fonction '$plusfunc' n'est pas définie", 'cachelab_erreur');
    122                         return;
    123                 }
    124         }
    125         else
     127                        spip_log("La fonction '$plusfunc' n'est pas définie", 'cachelab_erreur');
     128                        return null;
     129                }
     130        } else {
    126131                $plusfunc = '';
     132        }
    127133
    128134        // options
    129135        // explode+strpos par défaut pour les chemins
    130         $methode_chemin = (isset ($options['methode_chemin']) ? $options['methode_chemin'] : 'strpos');
    131         $partie_chemin = (isset ($options['partie_chemin']) ? $options['partie_chemin'] : 'tout');
     136        $methode_chemin = (isset($options['methode_chemin']) ? $options['methode_chemin'] : 'strpos');
     137        $partie_chemin = (isset($options['partie_chemin']) ? $options['partie_chemin'] : 'tout');
    132138        // clean par défaut
    133         $do_clean = (isset ($options['clean']) ? $options['clean'] : (!defined('CACHELAB_CLEAN') or CACHELAB_CLEAN));
     139        $do_clean = (isset($options['clean']) ? $options['clean'] : (!defined('CACHELAB_CLEAN') or CACHELAB_CLEAN));
    134140        // pas de listes par défaut
    135         $do_lists = ($action == 'list') or (isset ($options['list']) and $options['list']);
    136         include_spip ('lib/microtime.inc');
    137         microtime_do ('begin');
     141        $do_lists = ($action == 'list') or (isset($options['list']) and $options['list']);
     142        include_spip('lib/microtime.inc');
     143        microtime_do('begin');
    138144
    139145        // retours
     
    147153        $len_prefix = strlen(_CACHE_NAMESPACE);
    148154
    149         foreach($cache['cache_list'] as $i => $d) {
     155        foreach ($cache['cache_list'] as $i => $d) {
    150156                // on "continue=passe au suivant" dés qu'on sait que le cache n'est pas cible
    151157
     
    155161                // on saute les caches d'autres origines
    156162                // (et les caches d'un autre _CACHE_NAMESPACE pour ce même site)
    157                 if (strpos ($cle, _CACHE_NAMESPACE) !== 0) {
     163                if (strpos($cle, _CACHE_NAMESPACE) !== 0) {
    158164                        $stats['nb_alien']++;
    159165                        continue;
     
    161167
    162168                // on ne veut examiner que les caches de squelettes SPIP
    163                 if (substr($cle, $len_prefix-1, 7) != ':cache:')
    164                         continue;
     169                if (substr($cle, $len_prefix-1, 7) != ':cache:') {
     170                        continue;
     171                }
    165172
    166173                // effacer ou sauter les caches invalidés par une invalidation totale
     
    169176                        or !apcu_exists($cle)) {
    170177                        if ($do_clean) {
    171                                 $del=$Memoization->del(substr($cle,$len_prefix));
    172                                 if (!$del)
    173                                         spip_log ("Echec du clean du cache $cle (création : {$d['creation_time']}, invalidation : $meta_derniere_modif)", "cachelab_erreur");
     178                                $del=$Memoization->del(substr($cle, $len_prefix));
     179                                if (!$del) {
     180                                        spip_log("Echec du clean du cache $cle (création : {$d['creation_time']}, invalidation : $meta_derniere_modif)", 'cachelab_erreur');
     181                                }
    174182                                $stats['nb_clean']++;
    175183                        };
     
    182190                // 1er filtrage : par la session
    183191                if ($session) {
    184                         if (substr ($cle, -9) != "_$session")
    185                                 continue;
     192                        if (substr($cle, -9) != "_$session") {
     193                        continue;
     194                        }
    186195                }
    187196
     
    189198                if ($chemin) {
    190199                        switch ($partie_chemin) {
    191                         case 'tout' :
    192                         case 'chemin' :
     200                        case 'tout':
     201                        case 'chemin':
    193202                                $partie_cle = $cle;
    194                                 break;
    195                         case 'fichier' :
     203                                        break;
     204                        case 'fichier':
    196205                                $parties = explode('/', $cle);
    197206                                $partie_cle = array_pop($parties);
    198                                 break;
    199                         case 'dossier' :
     207                                        break;
     208                        case 'dossier':
    200209                                $parties = explode('/', $cle);
    201210                                $parties = array_pop($parties);
    202211                                $partie_cle = array_pop($parties);
    203                                 break;
    204                         default :
    205                                 spip_log ("Option partie_chemin incorrecte : '$partie_chemin'", 'cachelab_erreur');
    206                                 return;
     212                                        break;
     213                        default:
     214                                spip_log("Option partie_chemin incorrecte : '$partie_chemin'", 'cachelab_erreur');
     215                                        return null;
    207216                        }
    208                         // mémo php : « continue resumes execution just before the closing curly bracket ( } ), and break resumes execution just after the closing curly bracket. »
     217                        // mémo php : « continue resumes execution just before the closing curly bracket ( } ),
     218                        // and break resumes execution just after the closing curly bracket. »
    209219                        switch ($methode_chemin) {
    210                         case 'strpos' :
    211                                 foreach ($chemins as $unchemin)
    212                                         if ($unchemin and (strpos ($partie_cle, $unchemin) !== false))
     220                        case 'strpos':
     221                                foreach ($chemins as $unchemin) {
     222                                        if ($unchemin and (strpos($partie_cle, $unchemin) !== false)) {
    213223                                                break 2;        // trouvé : sort du foreach et du switch et poursuit le test des autres conditions
    214                                 continue 2;      // échec : passe à la $cle suivante
    215                         case 'regexp' :
    216                                 if ($chemin and ($danslechemin = preg_match(",$chemin,i", $partie_cle)))
     224                                        }
     225                                }
     226                                        continue 2;      // échec : passe à la $cle suivante
     227                        case 'regexp':
     228                                if ($chemin and ($danslechemin = preg_match(",$chemin,i", $partie_cle))) {
    217229                                        break;  // trouvé : poursuit le test des autres conditions
    218                                 continue 2;     // échec : passe à la clé suivante
    219                         default :
    220                                 spip_log ("Méthode '$methode_chemin' pas prévue pour le filtrage par le chemin", 'cachelab_erreur');
    221                                 return;
     230                                }
     231                                        continue 2;     // échec : passe à la clé suivante
     232                        default:
     233                                spip_log("Méthode '$methode_chemin' pas prévue pour le filtrage par le chemin", 'cachelab_erreur');
     234                                        return null;
    222235                        };
    223236                }
     
    228241                        $data = $Memoization->get(substr($cle, $len_prefix));
    229242                        if (!$data or !is_array($data)) {
    230                                 spip_log ("clé=$cle : data est vide ou n'est pas un tableau : ".print_r($data,1), 'cachelab_erreur');
     243                                spip_log("clé=$cle : data est vide ou n'est pas un tableau : ".print_r($data, 1), 'cachelab_erreur');
    231244                                continue;
    232245                        };
     
    235248                // 3eme filtre : par une valeur dans l'environnement
    236249                if ($cle_objet
    237                         and (!isset ($data['contexte'][$cle_objet])
    238                                 or ($data['contexte'][$cle_objet]!=$id_objet)))
    239                         continue;
     250                        and (!isset($data['contexte'][$cle_objet])
     251                                or ($data['contexte'][$cle_objet]!=$id_objet))) {
     252                        continue;
     253                }
    240254
    241255                // 4eme filtre : par une extension
    242256                if ($plusfunc
    243                         and !$plusfunc ($action, $conditions, $options, $cle, $data, $stats))
    244                         continue;
     257                        and !$plusfunc($action, $conditions, $options, $cle, $data, $stats)) {
     258                        continue;
     259                }
    245260
    246261                // restent les cibles
    247262                $stats['nb_cible']++;
    248                 if ($do_lists)
     263                if ($do_lists) {
    249264                        $stats['l_cible'][] = $cle;
    250 
    251                 cachelab_appliquer ($action, $cle, $data, $options, $return);
    252 
    253                 if ($return
    254                         and (($action=='get')
    255                                 or (substr($action,0,4)=='get_')))
     265                }
     266
     267                cachelab_appliquer($action, $cle, $data, $options, $return);
     268
     269                if ($return
     270                        and (($action=='get')
     271                                or (substr($action, 0, 4)=='get_'))) {
    256272                        return $return; // TODO chrono aussi dans ce cas
    257         }
    258 
    259         $stats['chrono'] = microtime_do ('end', 'ms');
    260         $msg = "cachelab_cibler($action) en {$stats['chrono']} ms ({$stats['nb_cible']} caches sur {$stats['nb_candidats']})"
     273                }
     274        }
     275
     276        $stats['chrono'] = microtime_do('end', 'ms');
     277        $msg = "cachelab_cibler($action) en {$stats['chrono']}ms ({$stats['nb_cible']} caches sur {$stats['nb_candidats']})"
    261278                ."\n".print_r($conditions, 1);
    262         if (count($options))
     279        if (count($options)) {
    263280                $msg .= "\n".print_r($options, 1);
    264         if (defined ('LOG_CACHELAB_CHRONO') and LOG_CACHELAB_CHRONO)
    265                 spip_log ($msg, 'cachelab_chrono.'._LOG_INFO);
    266         if (defined ('LOG_CACHELAB_SLOW') and ($stats['chrono']  > LOG_CACHELAB_SLOW))
    267                 spip_log ($msg, 'cachelab_slow.'._LOG_INFO_IMPORTANTE);
    268         if (($action=='del') and defined ('LOG_CACHELAB_TOOMANY_DEL') and ($stats['nb_cible']  > LOG_CACHELAB_TOOMANY_DEL))
    269                 spip_log ($msg, 'cachelab_toomany_del.'._LOG_INFO_IMPORTANTE);
    270 
    271         if ($return)
     281        }
     282        if (defined('LOG_CACHELAB_CHRONO') and LOG_CACHELAB_CHRONO) {
     283                spip_log($msg, 'cachelab_chrono.'._LOG_INFO);
     284        }
     285        if (defined('LOG_CACHELAB_SLOW') and ($stats['chrono']  > LOG_CACHELAB_SLOW)) {
     286                spip_log($msg, 'cachelab_slow.'._LOG_INFO_IMPORTANTE);
     287        }
     288        if (($action=='del') and defined('LOG_CACHELAB_TOOMANY_DEL') and ($stats['nb_cible']  > LOG_CACHELAB_TOOMANY_DEL)) {
     289                spip_log($msg, 'cachelab_toomany_del.'._LOG_INFO_IMPORTANTE);
     290        }
     291
     292        if ($return) {
    272293                $stats['val'] = $return;
     294        }
    273295        return $stats;
    274296}
     
    278300 * @param array $objets_invalidants
    279301 */
    280 function controler_invalideur($action, $objets_invalidants=array()) {
     302function controler_invalideur($action, $objets_invalidants = array()) {
    281303static $prev_derniere_modif_invalide;
    282         switch($action) {
    283         case 'stop' :
     304        switch ($action) {
     305        case 'stop':
    284306                $objets_invalidants = array();
    285307                // nobreak;
    286         case 'select' :
     308        case 'select':
    287309                $prev_derniere_modif_invalide = $GLOBALS['derniere_modif_invalide'];
    288                 if (is_array($objets_invalidants))
     310                if (is_array($objets_invalidants)) {
    289311                        $GLOBALS['derniere_modif_invalide'] = $objets_invalidants;
    290                 break;
    291         case 'go' :
     312                }
     313                        break;
     314        case 'go':
    292315                $GLOBALS['derniere_modif_invalide'] = $prev_derniere_modif_invalide;
    293                 break;
     316                        break;
    294317        }
    295318}
     
    298321// Exemple d'extension utilisable avec 'plus'=>'contexte'
    299322// Filtrer non sur une seule valeur de l'environnement comme avec 'cle_objet'
    300 // mais sur un ensemble de valeurs spécifié par $conditions['contexte'] 
     323// mais sur un ensemble de valeurs spécifié par $conditions['contexte']
    301324// qui est un tableau de (clé, valeur)
    302325// Toutes les valeurs doivent être vérifiées dans l'environnement.
    303 // 
     326//
    304327/**
    305328 * @param $action
     
    312335 */
    313336function cachelab_ciblercache_contexte($action, $conditions, $options, $cle, &$data, &$stats) {
    314         if (!isset ($data['contexte'])
     337        if (!isset($data['contexte'])
    315338                or !isset($conditions['contexte'])
    316                 or !is_array($conditions['contexte']))
     339                or !is_array($conditions['contexte'])) {
    317340                return false;
     341        }
    318342        $diff = array_diff_assoc($conditions['contexte'], $data['contexte']);
    319343        return empty($diff);
  • _plugins_/cachelab/trunk/inc/cachelab_invalideur.php

    r115351 r115426  
    1010include_spip('inc/cachelab_utils');
    1111
    12 if (!defined('LOG_BALISECACHE_FILTRES'))
     12if (!defined('LOG_BALISECACHE_FILTRES')) {
    1313        define('LOG_BALISECACHE_FILTRES', 'oui');
    14 
    15 if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES'))
     14}
     15
     16if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES')) {
    1617        define('LOG_BALISECACHE_DUREES_DYNAMIQUES', false);
     18}
    1719
    1820
     
    2729 * tout le site (sur la meta `derniere_modif`)
    2830 *
    29  * @global derniere_modif_invalide
     31 * @global bool|array derniere_modif_invalide
    3032 *     Par défaut à `true`, la meta `derniere_modif` est systématiquement
    3133 *     calculée dès qu'un invalideur se présente. Cette globale peut
     
    5557                        ecrire_meta('derniere_modif_extra_' . $r[1], time());
    5658                        $f="cachelab_suivre_invalideur_{$r[1]}";
    57                 }
    58                 else {
     59                } else {
    5960                        // stocker la date_modif_$objet (ne sert a rien)
    6061                        ecrire_meta('derniere_modif_' . $objet, time());
     
    6364
    6465                if (function_exists($f)) {
    65                         spip_log ("suivre_invalideur appelle $f($cond,$modif)", "cachelab");
     66                        spip_log("suivre_invalideur appelle $f($cond,$modif)", 'cachelab');
    6667                        $modif = $f($cond, $modif);      // $f renvoie la nouvelle valeur de $modif
    6768                        // si l'invalidation a été totalement traitée par $f, ya plus rien à faire
    68                         if (!$modif)
     69                        if (!$modif) {
    6970                                return;
     71                        }
    7072                }
    7173        }
     
    7880                        and in_array($objet, $GLOBALS['derniere_modif_invalide']))) {
    7981                ecrire_meta('derniere_modif', time());
    80                 include_spip ('inc/cachelab');
    81                 spip_log ("invalidation totale / signal '$cond' avec objet '$objet'", "suivre_invalideur");
    82         }
    83         else
    84                 spip_log ("invalidation totale évitée : $cond", "cachelab_effondrement_evite");
     82                include_spip('inc/cachelab');
     83                spip_log("invalidation totale / signal '$cond' avec objet '$objet'", 'suivre_invalideur');
     84        } else {
     85                spip_log("invalidation totale évitée : $cond", 'cachelab_effondrement_evite');
     86        }
    8587}
    8688
     
    9092//
    9193// Appelé à la fin de creer_cache
    92 // $page est le tableau décrivant le cache qui vient d'être calculé 
    93 // avec les clés suivantes pour ses métadonnées : 
     94// $page est le tableau décrivant le cache qui vient d'être calculé
     95// avec les clés suivantes pour ses métadonnées :
    9496// squelette,source,process_ins,invalideurs,entetes,duree,texte,notes,contexte,lastmodified,sig
    9597// http://code.spip.net/@maj_invalideurs
    9698//
    9799// S'il y a une entete X-Spip-Methode-Duree-Cache on récupère la méthode
    98 // et on appelle la fonction cachelab_calcule_duree_cache_lamethode 
     100// et on appelle la fonction cachelab_calcule_duree_cache_lamethode
    99101// avec en argument la valeur de l'argument dans l'envt ou de date_creation par défaut
    100102// On corrige alors la durée du cache avec la valeur retournée.
     
    108110function maj_invalideurs($fichier, &$page) {
    109111global $Memoization;
    110 // Rq : ici, le texte du cache est non zipé (cf function creer_cache dans memoization), 
     112// Rq : ici, le texte du cache est non zipé (cf function creer_cache dans memoization),
    111113// tandis que la version en cache peut être zipée (avec index 'gz').
    112         if  (LOG_INVALIDATION_CORE) {
     114        if (LOG_INVALIDATION_CORE) {
    113115                // Abondamment appelé. À part pour pas noyer les autres
    114                 spip_log ("maj_invalideurs($fichier, &page)", "invalideur_core_maj_invalideurs");
    115                 spip_log ("maj_invalideurs($fichier, &page)\n".print_r($page,1), "invalideur_core_maj_invalideurs_details");
     116                spip_log("maj_invalideurs($fichier, &page)", 'invalideur_core_maj_invalideurs');
     117                spip_log("maj_invalideurs($fichier, &page)\n".print_r($page, 1), 'invalideur_core_maj_invalideurs_details');
    116118        };
    117119
    118120static $var_cache;
    119121        $infos = $hint_squel = '';
    120         if (!isset($var_cache))
     122        if (!isset($var_cache)) {
    121123                $var_cache = _request('var_cache');
    122         if ($var_cache=='sessionnement') // on veut le sessionnement seul à l'écran
     124        }
     125        if ($var_cache=='sessionnement') { // on veut le sessionnement seul à l'écran
    123126                $hint_squel = ' title="'.attribut_html($page['source']).'" ';
    124         else
     127        } else {
    125128                $infos = $page['source'];               // on prépare les infos supplémentaires
     129        }
    126130
    127131        // Pour le calcul dynamique d'une durée de cache, la fonction user
     
    133137                if (function_exists($f)) {
    134138                        if (!isset($page['contexte'][$arg])) {
    135                                 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");
     139                                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');
    136140                                return;
    137141                        }
    138                         $duree = $f($page['contexte'][$arg],$page);
     142                        $duree = $f($page['contexte'][$arg], $page);
    139143                        if (!is_null($duree)) {
    140                                 if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES)
    141                                         spip_log ("#CACHE $f (arg={$page['contexte'][$arg]}) renvoie : $duree s", 'balisecache_duree_dynamique');
    142 
    143                                 if ($var_cache)
     144                                if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES) {
     145                                        spip_log("#CACHE $f (arg={$page['contexte'][$arg]}) renvoie : $duree s", 'balisecache_duree_dynamique');
     146                                }
     147
     148                                if ($var_cache) {
    144149                                        echo "<div class='cachelab_blocs' $hint_squel><h6>Durée dynamique : $duree</h6><small>$infos</small></div>";
     150                                }
    145151
    146152                                $page['duree'] = $duree;
     
    157163                                $Memoization->set($fichier, $page, 3600+$duree);
    158164                        }
    159                 }
    160                 else
    161                         spip_log ("#CACHE duree cache : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page,1), "cachelab_erreur");
     165                } else {
     166                        spip_log("#CACHE duree cache : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page, 1), 'cachelab_erreur');
     167                }
    162168        }
    163169       
    164170        // Exemple : <INCLURE{fond=mes_scores,duree-cache=#GET{duree_sicestmoi_oupas}}/>
    165171        if (isset($page['contexte']['duree-cache'])) {
    166                 if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES)
    167                         spip_log ("Pour $fichier, contexte[duree-cache]={$page['contexte']['duree-cache']}", 'balisecache_duree_dynamique');
    168 
    169                 if ($var_cache)
     172                if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES) {
     173                        spip_log("Pour $fichier, contexte[duree-cache]={$page['contexte']['duree-cache']}", 'balisecache_duree_dynamique');
     174                }
     175
     176                if ($var_cache) {
    170177                        echo "<div class='cachelab_blocs' $hint_squel><h6>Contexte duree-cache : $duree</h6><small>$infos</small></div>";
     178                }
    171179
    172180                $page['entetes']['X-Spip-Cache']
    173181                = $page['entetes']['X-Spip-Contexte-Duree-Cache']
    174                 = $page['duree'] 
    175                 = $duree 
     182                = $page['duree']
     183                = $duree
    176184                = intval($page['contexte']['duree-cache']);
    177185
     
    188196                list ($f, $arg) = split_first_arg($f);
    189197                if (function_exists($f)) {
    190                         if (!defined('LOG_BALISECACHE_FILTRES') or LOG_CACHELAB_FILTRES)
    191                                 spip_log ("#CACHE appelle le filtre $f ($arg)", 'balisecache_filtres');
     198                        if (!defined('LOG_BALISECACHE_FILTRES') or LOG_BALISECACHE_FILTRES) {
     199                                spip_log("#CACHE appelle le filtre $f ($arg)", 'balisecache_filtres');
     200                        }
    192201                        $toset = $f($page, $arg);
    193202                        // Le filtre renvoie un booléen qui indique s'il faut mémoizer le cache
    194                         if ($toset)
     203                        if ($toset) {
    195204                                $Memoization->set($fichier, $page, $page['entete']['X-Spip-Cache']);
    196                 }
    197                 else
    198                         spip_log ("#CACHE filtre : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page,1), "cachelab_erreur");
     205                        }
     206                } else {
     207                        spip_log("#CACHE filtre : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page, 1), 'cachelab_erreur');
     208                }
    199209        }
    200210       
    201         if ($var_cache)
     211        if ($var_cache) {
    202212                echo '<div class="cachelab_blocs" '.$hint_squel.'><h6>Sessionnement : '
    203213                                .cachelab_etat_sessionnement($page['invalideurs'], 'précis')
    204214                         .'</h6><small>'.$infos.'</small></div>';
    205 }
     215        }
     216}
  • _plugins_/cachelab/trunk/inc/cachelab_utils.php

    r112671 r115426  
    77//
    88// sépare à la lisp le premier mot et les autres
    9 // 
     9//
    1010// $f (string) : liste à séparer
    1111// $cdr (string ou array) : valeur par défaut pour le 2eme élt renvoyé
     
    1616// retour[1] (string ou array selon $string_wanted) : reste de la liste
    1717//
    18 function split_first_arg($l, $cdr='', $string_wanted=true) {
     18function split_first_arg($l, $cdr = '', $string_wanted = true) {
    1919        $l = preg_replace('/\s+/', ' ', trim($l), -1, $n);
    2020        $lparts = explode(' ', $l);
    2121        if ($lparts != array_filter($lparts)) {
    22             spip_log ("split_first_arg($l, $cdr, $string_wanted); mauvais format du 1er argument".print_r($lparts,1), "cachelab_ASSERT");
    23             exit;
     22                spip_log("split_first_arg($l, $cdr, $string_wanted); mauvais format du 1er argument".print_r($lparts, 1), 'cachelab_ASSERT');
     23                exit;
    2424        }
    2525        $car = array_shift($lparts);
    2626        if (!$car) {
    27             spip_log ("split_first_arg($l,$cdr,$string_wanted) : pb avec le 1er argument, reste lparts=".print_r($lparts,1), "cachelab_ASSERT");
    28             exit;
     27                spip_log("split_first_arg($l,$cdr,$string_wanted) : pb avec le 1er argument, reste lparts=".print_r($lparts, 1), 'cachelab_ASSERT');
     28                exit;
    2929        }
    3030
    3131        if ($lparts) {
    32             if ($string_wanted)
    33                     $cdr = implode(' ', $lparts);
    34             else
    35                     $cdr = $lparts;
     32                if ($string_wanted) {
     33                        $cdr = implode(' ', $lparts);
     34                } else {
     35                        $cdr = $lparts;
     36                }
    3637        }
    3738
     
    3940}
    4041
    41 function split_f_arg($f, $arg='') {
    42         spip_log("split_f_arg($f, $arg", "cachelab_OBSOLETE");
    43         return split_first_arg ($f, $arg);
     42function split_f_arg($f, $arg = '') {
     43        spip_log("split_f_arg($f, $arg", 'cachelab_OBSOLETE');
     44        return split_first_arg($f, $arg);
    4445}
    4546
    46 function slug_chemin($chemin, $sep='_') {
    47         return str_replace ('/', $sep, $chemin);
     47function slug_chemin($chemin, $sep = '_') {
     48        return str_replace('/', $sep, $chemin);
    4849}
    4950
     
    5455        }
    5556}
    56 
  • _plugins_/cachelab/trunk/inc/invalideur.php

    r113576 r115426  
    9393        for ($i=0; $i < 256; $i++) {
    9494                $dir = _DIR_CACHE.sprintf('%02s', dechex($i));
    95                 if (@is_dir($dir) AND is_readable($dir) AND $d = @opendir($dir)) {
     95                if (@is_dir($dir) and is_readable($dir) and $d = @opendir($dir)) {
    9696                        while (($f = readdir($d)) !== false) {
    97                                 if (preg_match(',^[[0-9a-f]+\.cache$,S', $f) AND $a = stat("$dir/$f")) {
     97                                if (preg_match(',^[[0-9a-f]+\.cache$,S', $f) and $a = stat("$dir/$f")) {
    9898                                        $n++;
    9999                                        if ($a['mtime'] >= $time) {
     
    135135 **/
    136136function purger_repertoire($dir, $options = array()) {
    137         $handle = @opendir($dir);
     137        if (!is_dir($dir) or !is_readable($dir)) {
     138                return;
     139        }
     140        $handle = opendir($dir);
    138141        if (!$handle) {
    139142                return;
     
    158161                        if (is_dir($chemin)) {
    159162                                $opts = $options;
    160                                 if (isset($otpions['limit'])) {
    161                                         $otps['limit'] = $otpions['limit'] - $total;
     163                                if (isset($options['limit'])) {
     164                                        $opts ['limit'] = $options['limit'] - $total;
    162165                                }
    163166                                $total += purger_repertoire($chemin, $opts);
     
    196199        list($nombre, $taille) = nombre_de_fichiers_repertoire($dir);
    197200        $total_cache = $taille * $nombre;
    198         if ($total_cache)       // Ajout / core car c'est vide avec la memoization
     201        if ($total_cache) {     // Ajout / core car c'est vide avec la memoization
    199202                spip_log("Taille du CACHE estimee ($l): "
    200                         . (intval(16 * $total_cache / (1024 * 1024 / 10)) / 10) . " Mo", "invalideur");
     203                        . (intval(16 * $total_cache / (1024 * 1024 / 10)) / 10) . ' Mo', 'invalideur');
     204        }
    201205
    202206        // Nombre max de fichiers a supprimer
     
    207211                $trop = 3 * intval($trop / $taille);
    208212                if ($trop > 0) {
    209                         $n = purger_repertoire($dir,
     213                        $n = purger_repertoire(
     214                                $dir,
    210215                                array(
    211216                                        'atime' => time() - _AGE_CACHE_ATIME,
     
    214219                                )
    215220                        );
    216                         spip_log("$dir : $n/$trop caches supprimes [taille moyenne $taille]", "invalideur");
     221                        spip_log("$dir : $n/$trop caches supprimes [taille moyenne $taille]", 'invalideur');
    217222                        $total_cache = intval(max(0, (16 * $total_cache) - $n * $taille) / (1024 * 1024) * 10) / 10;
    218                         spip_log("cache restant estime : $total_cache Mo, ratio " . $total_cache / $GLOBALS['quota_cache'], "invalideur");
     223                        spip_log("cache restant estime : $total_cache Mo, ratio " . $total_cache / $GLOBALS['quota_cache'], 'invalideur');
    219224
    220225                        // redemander la main pour eviter que le cache ne gonfle trop
     
    225230                        ) {
    226231                                $encore = true;
    227                                 spip_log("Il faut encore purger", "invalideur");
     232                                spip_log('Il faut encore purger', 'invalideur');
    228233                        }
    229234                }
     
    242247
    243248        if (preg_match(
    244                 "|^([0-9a-f]/)?([0-9]+/)?[0-9a-f]+\.cache(\.gz)?$|i",
    245                 $cache)) {
     249                '|^([0-9a-f]/)?([0-9]+/)?[0-9a-f]+\.cache(\.gz)?$|i',
     250                $cache
     251        )) {
    246252                // supprimer le fichier (de facon propre)
    247253                supprimer_fichier(_DIR_CACHE . $cache);
     
    258264##
    259265
    260 if  (!defined('LOG_INVALIDATION_CORE'))
    261         define ('LOG_INVALIDATION_CORE', false);
     266if (!defined('LOG_INVALIDATION_CORE')) {
     267        define('LOG_INVALIDATION_CORE', false);
     268}
    262269
    263270// Supprimer les caches marques "x"
     
    268275        if (isset($GLOBALS['meta']['invalider_caches'])) {
    269276                effacer_meta('invalider_caches');
    270                 if  (LOG_INVALIDATION_CORE)
    271                         spip_log ("retire_caches($chemin = '') ne devrait pas être appelé car ['meta']['invalider_caches'] devrait être false", "invalideur_core_retire_caches_BUG");
     277                if (LOG_INVALIDATION_CORE) {
     278                        spip_log("retire_caches($chemin = '') ne devrait pas être appelé car ['meta']['invalider_caches'] devrait être false", 'invalideur_core_retire_caches_BUG');
     279                }
    272280        } # concurrence
    273         if  (LOG_INVALIDATION_CORE)
    274                 spip_log ("retire_caches($chemin = '')", "invalideur_core_retire_caches");
     281        if (LOG_INVALIDATION_CORE) {
     282                spip_log("retire_caches($chemin = '')", 'invalideur_core_retire_caches');
     283        }
    275284}
    276285
     
    287296//
    288297// http://code.spip.net/@supprime_invalideurs
    289 function supprime_invalideurs() {
    290         if  (LOG_INVALIDATION_CORE)
    291                 spip_log ("supprime_invalideurs()", "invalideur_core");
     298function supprime_invalideurs() {
     299        if (LOG_INVALIDATION_CORE) {
     300                spip_log('supprime_invalideurs()', 'invalideur_core');
     301        }
    292302}
    293303
    294304// les invalideurs sont en général de la forme "objet/id_objet"
    295305// http://code.spip.net/@insere_invalideur
    296 // JAMAIS appelé par le noyau, 
     306// JAMAIS appelé par le noyau,
    297307// ÉTAIT un hook post maj_invalideurs appelé avec $page['invalideurs'] et $fichier
    298 function insere_invalideur($inval, $fichier) {
    299         if  (LOG_INVALIDATION_CORE)
    300                 spip_log ("insere_invalideur($inval, $fichier)", "invalideur_core");
     308function insere_invalideur($inval, $fichier) {
     309        if (LOG_INVALIDATION_CORE) {
     310                spip_log("insere_invalideur($inval, $fichier)", 'invalideur_core');
     311        }
    301312}
    302313
     
    307318// JAMAIS appelé par le noyau
    308319// ÉTAIT un hook post suivre_invalideur avec la liste calculée des fichiers caches à invalider
    309 function applique_invalideur($depart) {
    310         if  (LOG_INVALIDATION_CORE)
    311                 spip_log ("applique_invalideur($depart)", "invalideur_core");
    312 }
     320function applique_invalideur($depart) {
     321        if (LOG_INVALIDATION_CORE) {
     322                spip_log("applique_invalideur($depart)", 'invalideur_core');
     323        }
     324}
  • _plugins_/cachelab/trunk/lib/microtime.inc.php

    r111815 r115426  
    33// Chronométrage des appels php
    44
    5 function eleg_microtime($time, $unit='') {
     5function eleg_microtime($time, $unit = '') {
    66        $time = round($time, 6);
    77
    88        switch ($unit) {
    9         case 'ms' :
    10                 return ($time*1000).' ms';
    11         case 'us' :
    12         case 'µs' :
    13                 return ($time*1000000).' µs';
    14         case 's' : nobreak;
    15                 return $time.'s';
    16         case '' :
    17                 return $time;
     9        case 'ms':
     10                        return ($time*1000).' ms';
     11        case 'us':
     12        case 'µs':
     13                        return ($time*1000000).' µs';
     14        case 's':
     15                        nobreak;
     16                        return $time.'s';
     17        case '':
     18                        return $time;
    1819        }
     20        spip_log('mauvais parametre unit pour eleg_microtime', 'erreur_microtime');
     21        return '';
    1922}
    2023// microtime_do reçoit des commandes et l'unité d'affichage us, ms ou s
     
    2326// end : now + begin
    2427// last : microtime depuis le dernier appel, sauf now
    25 function microtime_do ($command, $unit='') {
     28function microtime_do($command, $unit = '') {
    2629static $u_init = 0;
    2730static $s_init = 0;
     
    2932static $s_last = 0;
    3033        switch ($command) {
    31         case 'begin' :
    32         case 'init' :
     34        case 'begin':
     35        case 'init':
    3336                list ($u_last, $s_last) = list ($u_init, $s_init) = explode(' ', microtime());
    34                 return 0;
     37                        return 0;
    3538
    36         case 'now' :
    37                 list ($u_last, $s_last) = explode(' ', microtime()); 
    38                 return eleg_microtime(($s_last - $s_init)+($u_last - $u_init), $unit);
     39        case 'now':
     40                list ($u_last, $s_last) = explode(' ', microtime());
     41                        return eleg_microtime(($s_last - $s_init)+($u_last - $u_init), $unit);
    3942
    40         case 'end' :
    41                 list ($u_last, $s_last) = explode(' ', microtime()); 
     43        case 'end':
     44                list ($u_last, $s_last) = explode(' ', microtime());
    4245                $res = ($s_last - $s_init)+($u_last - $u_init);
    4346                $u_init = $u_last;
    4447                $s_init = $s_last;
    45                 return eleg_microtime($res, $unit);
     48                        return eleg_microtime($res, $unit);
    4649
    47         case 'last' :
    48                 list ($u_now, $s_now) = explode(' ', microtime()); 
     50        case 'last':
     51                list ($u_now, $s_now) = explode(' ', microtime());
    4952                $res = ($s_now - $s_last)+($u_now - $u_last);
    5053                $u_last = $u_now;
    5154                $s_last = $s_now;
    52                 return eleg_microtime($res, $unit);
     55                        return eleg_microtime($res, $unit);
    5356
    54         default :
    55                 die ("unknown microtime_do command « $command »");
    56         };
     57        default:
     58                        die("unknown microtime_do command « $command »");
     59        }
    5760};
  • _plugins_/cachelab/trunk/paquet.xml

    r115318 r115426  
    11<paquet
    22        prefix="cachelab"
    3         categorie="outil"
    4         version="0.99.0"
     3        categorie="performance"
     4        version="0.99.1"
    55        etat="dev"
    66        compatibilite="[3.0.0;3.3.*]"
     
    99>
    1010        <nom>CacheLab</nom>
    11         <!-- Invalidation ciblée et autres actions sur des caches APC filtrés des squelettes SPIP -->
     11        <!-- Invalidation ciblée et autres actions sur les caches APC filtrés des squelettes SPIP -->
    1212        <auteur lien="https://contrib.spip.net/JLuc">JLuc</auteur>
    1313        <credit lien="https://thenounproject.com/term/lab/1796357/">Icone de Nawicon Studio, Licence Creative Commons</credit>
  • _plugins_/cachelab/trunk/public/cachelab_balises.php

    r113218 r115426  
    1616 * - `statique` ne respecte pas l'invalidation par modif de la base
    1717 *   (mais s'invalide tout de même à l'expiration du delai)
    18  * - `calcul-methode` où la partie `methode` est variable et indique 
    19  *    la méthode de calcul dynamique de la durée cache à partir 
     18 * - `calcul-methode` où la partie `methode` est variable et indique
     19 *    la méthode de calcul dynamique de la durée cache à partir
    2020 *    de son contenu yc ses métadonnées et notamment l'env
    21  *    Dans ce cas le 1er argument sert seulement pour compatibilité 
     21 *    Dans ce cas le 1er argument sert seulement pour compatibilité
    2222 *    si on désactive cachelab
    2323 *
     
    4242 *     ```
    4343 * @note
    44  *   En absence de durée indiquée par cette balise, 
     44 *   En absence de durée indiquée par cette balise,
    4545 *   la durée du cache est donnée
    4646 *   par la constante `_DUREE_CACHE_DEFAUT`
     
    5151 *     Pile complétée par le code à générer
    5252 **/
    53 function balise_CACHE ($p) {
     53function balise_CACHE($p) {
    5454        if ($p->param) {
    5555                $i = 0;
     
    111111                                $ajout = "'<'.'" . '?php header("X-Spip-Methode-Duree-Cache: '.$methode.'"); ?' . "'.'>'";
    112112                                $code .= $concat.$ajout;
    113                                 spip_log ("#CACHE($pa) sur $sourcefile avec méthode de calcul de la durée du cache : $methode", 'cachelab_OBSOLETE');
     113                                spip_log("#CACHE($pa) sur $sourcefile avec méthode de calcul de la durée du cache : $methode", 'cachelab_OBSOLETE');
    114114                        }
    115115
    116116                        if (strpos($pa, 'filtre-')===0) {
    117                                 $methode = substr($pa, 7); 
     117                                $methode = substr($pa, 7);
    118118                                $ajout = "'<'.'" . '?php header("X-Spip-Filtre-Cache: '.$methode.'"); ?' . "'.'>'";
    119                                 $code .= $concat.$ajout; 
    120                                 spip_log ("#CACHE($pa) sur $sourcefile avec filtre sur le cache complet : $methode", 'cachelab_OBSOLETE');
     119                                $code .= $concat.$ajout;
     120                                spip_log("#CACHE($pa) sur $sourcefile avec filtre sur le cache complet : $methode", 'cachelab_OBSOLETE');
    121121                        }
    122122// fin des syntaxes obsolètes
    123123
    124                         list ($func, $args) = split_first_arg ($pa);
     124                        list ($func, $args) = split_first_arg($pa);
    125125                        switch ($func) {
    126126                        // TODO : également traiter ici les morceaux du core traités plus haut
    127                         case 'statique' :
    128                         case 'duree' :
     127                        case 'statique':
     128                        case 'duree':
    129129                                $ajout = "'<'.'" . "?php header(\"X-Spip-Methode-Duree-Cache: $args\"); ?" . "'.'>'";
    130130                                $code .= $concat.$ajout;
    131                                 spip_log ("#CACHE{$pa} sur $sourcefile avec méthode de calcul de la durée du cache : $args", 'cachelab');
    132                                 break;
     131                                spip_log("#CACHE{$pa} sur $sourcefile avec méthode de calcul de la durée du cache : $args", 'cachelab');
     132                                        break;
    133133                       
    134                         case 'log' :
    135                         case 'session' :
    136                         case 'filtre' :
     134                        case 'log':
     135                        case 'session':
     136                        case 'filtre':
    137137                                $ajout = "'<'.'" . '?php header("X-Spip-Filtre-Cache: '.$pa.'"); ?' . "'.'>'";
    138                                 $code .= $concat.$ajout; 
    139                                 spip_log ("#CACHE{$pa} sur $sourcefile : filtre  $func($args) sur le cache complet", 'cachelab');
    140                                 break;
    141                         default :
    142                                 break;
     138                                $code .= $concat.$ajout;
     139                                spip_log("#CACHE{$pa} sur $sourcefile : filtre  $func($args) sur le cache complet", 'cachelab');
     140                                        break;
     141                        default:
     142                                        break;
    143143                        }
    144144                }
     
    154154
    155155//
    156 // Calcul de durée de cache dynamique progressive 
     156// Calcul de durée de cache dynamique progressive
    157157// adapté pour un affichage approximatif et habituel
    158158// du type "il y a 20 secondes", "il y a 3 minutes", "ce matin",
     
    169169function cachelab_duree_progapprox($date_creation) {
    170170        $dt_creation = new DateTime($date_creation);
    171         if (!$dt_creation)
     171        if (!$dt_creation) {
    172172                return _DUREE_CACHE_DEFAUT;
    173 
    174         $interval = $dt_creation->diff(new DateTime('NOW'),true); // valeur absolue
    175         if (!$interval)
     173        }
     174
     175        $interval = $dt_creation->diff(new DateTime('NOW'), true); // valeur absolue
     176        if (!$interval) {
    176177                return _DUREE_CACHE_DEFAUT;
    177         if ($interval->y > 2)
     178        }
     179        if ($interval->y > 2) {
    178180                return 6*30*24*3600; // 6 mois si plus de 2 ans
    179         if ($interval->y)
     181        }
     182        if ($interval->y) {
    180183                return 30*24*3600;      // 1 mois si plus d'un an
    181         if ($interval->m)
     184        }
     185        if ($interval->m) {
    182186                return 7*24*3600;       // 1 semaine si plus d'un mois
    183         if ($interval->d > 7)
     187        }
     188        if ($interval->d > 7) {
    184189                return 24*3600;         // 1 jour si plus d'une semaine
    185         if ($interval->d)
     190        }
     191        if ($interval->d) {
    186192                return 6*3600;          // 6h si plus d'un jour
    187         if ($interval->h > 6)
     193        }
     194        if ($interval->h > 6) {
    188195                return 3600;            // 1h si plus de 6h
    189         if ($interval->h)
     196        }
     197        if ($interval->h) {
    190198                return 30*60;           // 1/2h si plus d'1h
    191         if ($interval->i > 10)
     199        }
     200        if ($interval->i > 10) {
    192201                return 10*60;           // 10 minutes si plus de 10 minutes
    193         if ($interval->i)
     202        }
     203        if ($interval->i) {
    194204                return 60;                      // chaque minute si plus d'une minute
     205        }
    195206        return 10;                              // 10secondes si moins d'une minute
    196207}
     
    203214 */
    204215function cachelab_duree_jusqueminuit($date_unused) {
    205     return strtotime('tomorrow') + 300 - time();
     216        return strtotime('tomorrow') + 300 - time();
    206217}
    207218
     
    211222// (avec les / remplacés par des _)
    212223//
    213 // Exemples d'usages : 
     224// Exemples d'usages :
    214225//      #CACHE{3600,log} : log tout le cache, méta et html
    215226//      #CACHE{log lastmodified}  : log l'entrée lastmodified du cache
     
    219230function cachelab_filtre_log($cache, $arg) {
    220231        if (!is_array($cache) or !isset($cache['source']) or !isset($cache['lastmodified']) or !isset($cache['invalideurs'])) {
    221                 spip_log ("cachelab_duree_progapprox ne reçoit pas un cache mais".print_r($cache,1), "cachelab_assert");
     232                spip_log('cachelab_duree_progapprox ne reçoit pas un cache mais'.print_r($cache, 1), 'cachelab_assert');
    222233                return null;
    223234        }
    224235        $source_limace = slug_chemin($cache['source']);
    225236        $arg=trim($arg);
    226         if ($arg) { 
     237        if ($arg) {
    227238                if (strpos($arg, '/')) {        #CACHE{log i/j}
    228                         $ij=explode('/',$arg);
     239                        $ij=explode('/', $arg);
    229240                        $c = $cache[$i=trim(array_shift($ij))];
    230                         $c = $c[trim($j=array_shift($ij))];
    231                 }
    232                 else {                                          #CACHE{log i}
     241                        $c = $c[trim($j = array_shift($ij))];
     242                } else {                                                #CACHE{log i}
    233243                        $c = $cache[$arg];
    234244                }
    235         }
    236         else
    237                 $c = $cache;                            #CACHE{log}
    238         spip_log ("cache[$arg] : ".print_r($c,1), "cachelab_".$source_limace);
     245        } else {                $c = $cache;                            #CACHE{log}
     246        }
     247        spip_log("cache[$arg] : ".print_r($c, 1), 'cachelab_'.$source_limace);
    239248}
    240249
     
    256265// #CACHE{session assert oui_anonyme} s'assure que tous les emplois sont sessionnés avec un internaute identifié (inutile ?)
    257266// #CACHE{session assert anonyme} s'assure que tous les emplois sans internaute identifié
    258 // 
     267//
    259268// #CACHE{session log} loge l'état du sessionnement dans un cache dédié à ce squelette
    260269// #CACHE{session insert} insère à la fin du cache l'affichage de l'état du sessionnement
    261 // #CACHE{session echo} affiche l'état du sessionnement comme var_cache 
     270// #CACHE{session echo} affiche l'état du sessionnement comme var_cache
    262271// mais pour ce cache seulement et seulement pour les caches dynamiques
    263272//
    264 function cachelab_filtre_session (&$cache, $totarg) {
     273function cachelab_filtre_session(&$cache, $totarg) {
    265274        if (!is_array($cache) or !isset($cache['source']) or !isset($cache['lastmodified']) or !isset($cache['invalideurs'])) {
    266                 spip_log ("cachelab_filtre_assertsession ne reçoit pas un cache mais".print_r($cache,1), "cachelab_assert");
     275                spip_log('cachelab_filtre_assertsession ne reçoit pas un cache mais'.print_r($cache, 1), 'cachelab_assert');
    267276                return null;
    268277        }
     
    276285        $avec_echo = false;
    277286        switch ($func) {
    278                 case 'assert_echo' :
     287                case 'assert_echo':
    279288                        $avec_echo = true;
    280                 case 'assert' :
    281                         switch($what) {
    282                                 case 'oui_login' :
    283                                 case 'oui_anonyme' :
    284                                 case 'non' :
     289                case 'assert':
     290                        switch ($what) {
     291                                case 'oui_login':
     292                                case 'oui_anonyme':
     293                                case 'non':
    285294                                        $ok = ($sess==$what);
    286295                                        break;
    287                                 case 'anonyme' :
     296                                case 'anonyme':
    288297                                        $ok = empty($invalideurs['session']);   // oui_anonyme ou non
    289298                                        break;
    290                                 case 'oui' :
     299                                case 'oui':
    291300                                        $ok = isset($invalideurs['session']);   // oui_anonyme ou oui_login
    292301                                        break;
    293302                                default:
    294                                         spip_log ("Erreur de syntaxe : '$what' incorrect dans #CACHE{session $totarg}, il faut oui, oui_login, oui_anonyme, non ou anonyme", 'cachelab_erreur');
     303                                        spip_log("Erreur de syntaxe : '$what' incorrect dans #CACHE{session $totarg}, il faut oui, oui_login, oui_anonyme, non ou anonyme", 'cachelab_erreur');
    295304                                        break 2;
    296305                        }
    297                         if (!$ok)  {
    298                                 spip_log ("$source : session n'est pas '$what'. invalideurs=".print_r($invalideurs,1), "cachelab_assertsession");
     306                        if (!$ok) {
     307                                spip_log("$source : session n'est pas '$what'. invalideurs=".print_r($invalideurs, 1), 'cachelab_assertsession');
    299308                                if ($avec_echo) {
    300309                                        echo "<div class='cachelab_blocs cachelab_assert'>
     
    306315                        break;
    307316
    308         case 'insert' :
     317        case 'insert':
    309318                global $Memoization;
    310319                if (!isset($Memoization)) {
    311                         spip_log ("Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé", 'cachelab_erreur');
     320                        spip_log("Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé", 'cachelab_erreur');
    312321                        echo "<div class='cachelab_blocs'><h6>Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé</h6></div>";
    313322                        break;
     
    315324                $cache['texte'] .= '<'."?php echo '<div class=\"cachelab_blocs\"><h6>$source sessionné : $sess</h6></div>' ?>";
    316325                $cache['process_ins'] = 'php';
    317                 break;
    318         case 'echo' :
     326                        break;
     327        case 'echo':
    319328                echo "<div class='cachelab_blocs'><h6>$source sessionné : $sess</h6></div>";
    320                 break;
    321         case 'log' :
    322                 spip_log ('session : '.$sess, 'cachelab_session_'.$source_limace);
    323                 break;
    324         default :
    325                 spip_log ("Syntaxe incorrecte dans $source : $func inconnu dans #CACHE{session $totarg}", 'cachelab_erreur');
    326                 break;
    327         }
    328 }
    329 
    330 function cachelab_etat_sessionnement ($invalideurs, $detail=false) {
    331         if (!isset($invalideurs['session']))
     329                        break;
     330        case 'log':
     331                spip_log('session : '.$sess, 'cachelab_session_'.$source_limace);
     332                        break;
     333        default:
     334                spip_log("Syntaxe incorrecte dans $source : $func inconnu dans #CACHE{session $totarg}", 'cachelab_erreur');
     335                        break;
     336        }
     337}
     338
     339function cachelab_etat_sessionnement($invalideurs, $detail = false) {
     340        if (!isset($invalideurs['session'])) {
    332341                return 'non';
    333         if (!$detail)
     342        }
     343        if (!$detail) {
    334344                return 'oui';
    335         elseif ($invalideurs['session'])
     345        } elseif ($invalideurs['session']) {
    336346                return 'oui_login';
     347        }
    337348        return 'oui_anonyme';
    338349}
Note: See TracChangeset for help on using the changeset viewer.