www/ecrire/public/cacher.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2012                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 if (!defined('_ECRIRE_INC_VERSION')) return;
  14
  15 /**
  16  * Le format souhaite : "a/bout-d-url.md5" (.gz s'ajoutera pour les gros caches)
  17  * Attention a modifier simultanement le sanity check de
  18  * la fonction retire_cache() de inc/invalideur
  19  *
  20  * http://doc.spip.org/@generer_nom_fichier_cache
  21  *
  22  * @param array $contexte
  23  * @param array $page
  24  * @return string
  25  */
  26 function generer_nom_fichier_cache($contexte, $page) {
  27
  28         $cache = $page['contexte_implicite']['cache'] . '-';
  29
  30         foreach ($contexte as $var=>$val) {
  31                 $val = is_array($val) ? var_export($val,true) : strval($val);
  32                 $cache .= str_replace('-', '_', $val) . '-' ;
  33         }
  34
  35         $cache = str_replace('/', '_', rawurlencode($cache));
  36
  37         if (strlen($cache) > 24) {
  38                 $cache = preg_replace('/([a-zA-Z]{1,3})[^-_]*[-_]/', '\1-', $cache);
  39                 $cache = substr($cache, 0, 24);
  40         }
  41
  42         // Morceau de md5 selon HOST, $dossier_squelettes et $marqueur
  43         // permet de changer le nom du cache en changeant ceux-ci
  44         // donc, par exemple, de gerer differents dossiers de squelettes
  45         // en parallele, ou de la "personnalisation" via un marqueur (dont la
  46         // composition est totalement libre...)
  47         $md_cache = md5(
  48                 var_export($page['contexte_implicite'],true) . ' '
  49                 . var_export($contexte,true)
  50         );
  51
  52         $cache .= '-'.substr($md_cache, 1, 32-strlen($cache));
  53
  54         // Sous-repertoires 0...9a..f ; ne pas prendre la base _DIR_CACHE
  55         $rep = _DIR_CACHE;
  56
  57         $rep = sous_repertoire($rep, '', false,true);
  58         $subdir = sous_repertoire($rep, substr($md_cache, 0, 1), true,true);
  59         return $subdir.$cache;
  60 }
  61
  62 /**
  63  * Faut-il compresser ce cache ? A partir de 16ko ca vaut le coup
  64  * (pas de passage par reference car on veut conserver la version non compressee
  65  * pour l'afficher)
  66  * on positionne un flag gz si on comprime, pour savoir si on doit decompresser ou pas
  67  * http://doc.spip.org/@gzip_page
  68  *
  69  * @param array $page
  70  * @return array
  71  */
  72 function gzip_page($page) {
  73         if (function_exists('gzcompress') AND strlen($page['texte']) > 16*1024) {
  74                 $page['gz'] = true;
  75                 $page['texte'] = gzcompress($page['texte']);
  76         } else {
  77                 $page['gz'] = false;
  78         }
  79         return $page;
  80 }
  81
  82 /**
  83  * Faut-il decompresser ce cache ?
  84  * (passage par reference pour alleger)
  85  * on met a jour le flag gz quand on decompresse, pour ne pas risquer
  86  * de decompresser deux fois de suite un cache (ce qui echoue)
  87  *
  88  * http://doc.spip.org/@gunzip_page
  89  *
  90  * @param array $page
  91  * @return void
  92  */
  93 function gunzip_page(&$page) {
  94         if ($page['gz']) {
  95                 $page['texte'] = gzuncompress($page['texte']);
  96                 $page['gz'] = false; // ne pas gzuncompress deux fois une meme page
  97         }
  98 }
  99
 100 /**
 101  * gestion des delais d'expiration du cache...
 102  * $page passee par reference pour accelerer
 103  *
 104  * @param array $page
 105  * @param int $date
 106  * @return int
 107  * 1 si il faut mettre le cache a jour
 108  * 0 si le cache est valide
 109  * -1 si il faut calculer sans stocker en cache
 110  */
 111 /// http://doc.spip.org/@cache_valide
 112 function cache_valide(&$page, $date) {
 113
 114         if (defined('_VAR_NOCACHE') AND _VAR_NOCACHE) return -1;
 115         if (isset($GLOBALS['meta']['cache_inhib']) AND $_SERVER['REQUEST_TIME']<$GLOBALS['meta']['cache_inhib']) return -1;
 116         if (defined('_NO_CACHE')) return (_NO_CACHE==0 AND !isset($page['texte']))?1:_NO_CACHE;
 117         if (!$page OR !isset($page['texte']) OR !isset($page['entetes']['X-Spip-Cache'])) return 1;
 118
 119         // #CACHE{n,statique} => on n'invalide pas avec derniere_modif
 120         // cf. ecrire/public/balises.php, balise_CACHE_dist()
 121         if (!isset($page['entetes']['X-Spip-Statique']) OR $page['entetes']['X-Spip-Statique'] !== 'oui') {
 122
 123                 // Cache invalide par la meta 'derniere_modif'
 124                 // sauf pour les bots, qui utilisent toujours le cache
 125                 if (!_IS_BOT
 126                 AND $GLOBALS['derniere_modif_invalide']
 127                 AND $date < $GLOBALS['meta']['derniere_modif'])
 128                         return 1;
 129
 130                 // Apparition d'un nouvel article post-date ?
 131                 if ($GLOBALS['meta']['post_dates'] == 'non'
 132                 AND isset($GLOBALS['meta']['date_prochain_postdate'])
 133                 AND time() > $GLOBALS['meta']['date_prochain_postdate']) {
 134                         spip_log('Un article post-date invalide le cache');
 135                         include_spip('inc/rubriques');
 136                         ecrire_meta('derniere_modif', time());
 137                         calculer_prochain_postdate();
 138                         return 1;
 139                 }
 140
 141         }
 142
 143         // Sinon comparer l'age du fichier a sa duree de cache
 144         $duree = intval($page['entetes']['X-Spip-Cache']);
 145         if ($duree == 0)  #CACHE{0}
 146                 return -1;
 147         else if ($date + $duree < time())
 148                 return 1;
 149         else
 150                 return 0;
 151 }
 152
 153 /**
 154  * Creer le fichier cache
 155  * Passage par reference de $page par souci d'economie
 156  *
 157  * http://doc.spip.org/@creer_cache
 158  *
 159  * @param array $page
 160  * @param string $chemin_cache
 161  * @return void
 162  */
 163 function creer_cache(&$page, &$chemin_cache) {
 164
 165         // Ne rien faire si on est en preview, debug, ou si une erreur
 166         // grave s'est presentee (compilation du squelette, MySQL, etc)
 167         // le cas var_nocache ne devrait jamais arriver ici (securite)
 168         // le cas spip_interdire_cache correspond a une ereur SQL grave non anticipable
 169         if ((defined('_VAR_NOCACHE') AND _VAR_NOCACHE)
 170                 OR defined('spip_interdire_cache'))
 171                 return;
 172
 173         // Si la page c1234 a un invalideur de session 'zz', sauver dans
 174         // 'tmp/cache/MD5(chemin_cache)_zz'
 175         if (isset($page['invalideurs'])
 176         AND isset($page['invalideurs']['session'])) {
 177                 // on verifie que le contenu du chemin cache indique seulement
 178                 // "cache sessionne" ; sa date indique la date de validite
 179                 // des caches sessionnes
 180                 if (!lire_fichier(_DIR_CACHE . $chemin_cache, $tmp)
 181                 OR !$tmp = @unserialize($tmp)) {
 182                         spip_log('Creation cache sessionne '.$chemin_cache);
 183                         $tmp = array(
 184                                 'invalideurs' => array('session' => ''),
 185                                 'lastmodified' => time()
 186                         );
 187                         ecrire_fichier(_DIR_CACHE . $chemin_cache, serialize($tmp));
 188                 }
 189                 $chemin_cache .= '_'.$page['invalideurs']['session'];
 190         }
 191
 192         // ajouter la date de production dans le cache lui meme
 193         // (qui contient deja sa duree de validite)
 194         $page['lastmodified'] = time();
 195
 196
 197         // l'enregistrer, compresse ou non...
 198         $ok = ecrire_fichier(_DIR_CACHE . $chemin_cache,
 199                 serialize(gzip_page($page)));
 200
 201         spip_log("Creation du cache $chemin_cache pour "
 202                 . $page['entetes']['X-Spip-Cache']." secondes". ($ok?'':' (erreur!)'));
 203
 204         // Inserer ses invalideurs
 205         include_spip('inc/invalideur');
 206         maj_invalideurs($chemin_cache, $page);
 207
 208 }
 209
 210
 211 /**
 212  * purger un petit cache (tidy ou recherche) qui ne doit pas contenir de
 213  * vieux fichiers ; (cette fonction ne sert que dans des plugins obsoletes)
 214  *
 215  * http://doc.spip.org/@nettoyer_petit_cache
 216  *
 217  * @param string $prefix
 218  * @param int $duree
 219  * @return void
 220  */
 221 function nettoyer_petit_cache($prefix, $duree = 300) {
 222         // determiner le repertoire a purger : 'tmp/CACHE/rech/'
 223         $dircache = sous_repertoire(_DIR_CACHE,$prefix);
 224         if (spip_touch($dircache.'purger_'.$prefix, $duree, true)) {
 225                 foreach (preg_files($dircache,'[.]txt$') as $f) {
 226                         if (time() - (@file_exists($f)?@filemtime($f):0) > $duree)
 227                                 spip_unlink($f);
 228                 }
 229         }
 230 }
 231
 232
 233 /**
 234  * Interface du gestionnaire de cache
 235  * Si son 3e argument est non vide, elle passe la main a creer_cache
 236  * Sinon, elle recoit un contexte (ou le construit a partir de REQUEST_URI)
 237  * et affecte les 4 autres parametres recus par reference:
 238  * - use_cache qui vaut
 239  *     -1 s'il faut calculer la page sans la mettre en cache
 240  *      0 si on peut utiliser un cache existant
 241  *      1 s'il faut calculer la page et la mettre en cache
 242  * - chemin_cache qui est le chemin d'acces au fichier ou vide si pas cachable
 243  * - page qui est le tableau decrivant la page, si le cache la contenait
 244  * - lastmodified qui vaut la date de derniere modif du fichier.
 245  * Elle retourne '' si tout va bien
 246  * un message d'erreur si le calcul de la page est totalement impossible
 247  *
 248  * http://doc.spip.org/@public_cacher_dist
 249  *
 250  * @param array $contexte
 251  * @param int $use_cache
 252  * @param string $chemin_cache
 253  * @param array $page
 254  * @param int $lastmodified
 255  * @return string|void
 256  */
 257 function public_cacher_dist($contexte, &$use_cache, &$chemin_cache, &$page, &$lastmodified) {
 258
 259         # fonction de cache minimale : dire "non on ne met rien en cache"
 260         # $use_cache = -1; return;
 261
 262         // Second appel, destine a l'enregistrement du cache sur le disque
 263         if (isset($chemin_cache)) return creer_cache($page, $chemin_cache);
 264
 265         // Toute la suite correspond au premier appel
 266         $contexte_implicite = $page['contexte_implicite'];
 267
 268         // Cas ignorant le cache car completement dynamique
 269         if ($_SERVER['REQUEST_METHOD'] == 'POST'
 270           OR _request('connect')) {
 271                 $use_cache = -1;
 272                 $lastmodified = 0;
 273                 $chemin_cache = "";
 274                 $page = array();
 275                 return;
 276         }
 277
 278         // Controler l'existence d'un cache nous correspondant
 279         $chemin_cache = generer_nom_fichier_cache($contexte, $page);
 280         $lastmodified = 0;
 281
 282         // charger le cache s'il existe
 283         if (lire_fichier(_DIR_CACHE . $chemin_cache, $page))
 284                 $page = @unserialize($page);
 285         else
 286                 $page = array();
 287
 288         // s'il est sessionne, charger celui correspondant a notre session
 289         if (isset($page['invalideurs'])
 290         AND isset($page['invalideurs']['session'])) {
 291                 $chemin_cache_session = $chemin_cache . '_' . spip_session();
 292                 if (lire_fichier(_DIR_CACHE . $chemin_cache_session, $page_session)
 293                 AND $page_session = @unserialize($page_session)
 294                 AND $page_session['lastmodified'] >= $page['lastmodified'])
 295                         $page = $page_session;
 296                 else
 297                         $page = array();
 298         }
 299
 300
 301         // Faut-il effacer des pages invalidees (en particulier ce cache-ci) ?
 302         if (isset($GLOBALS['meta']['invalider'])) {
 303                 // ne le faire que si la base est disponible
 304                 if (spip_connect()) {
 305                         include_spip('inc/invalideur');
 306                         retire_caches($chemin_cache); # API invalideur inutile
 307                         supprimer_fichier(_DIR_CACHE.$chemin_cache);
 308                         if (isset($chemin_cache_session) and $chemin_cache_session)
 309                                 supprimer_fichier(_DIR_CACHE.$chemin_cache_session);
 310                 }
 311         }
 312
 313         // Si un calcul, recalcul [ou preview, mais c'est recalcul] est demande,
 314         // on supprime le cache
 315         if (defined('_VAR_MODE') && _VAR_MODE &&
 316                 (isset($_COOKIE['spip_session'])
 317                 || isset($_COOKIE['spip_admin'])
 318                 || @file_exists(_ACCESS_FILE_NAME))
 319         ) {
 320                 $page = array('contexte_implicite'=>$contexte_implicite); // ignorer le cache deja lu
 321                 include_spip('inc/invalideur');
 322                 retire_caches($chemin_cache); # API invalideur inutile
 323                 supprimer_fichier(_DIR_CACHE.$chemin_cache);
 324                 if (isset($chemin_cache_session) and $chemin_cache_session)
 325                         supprimer_fichier(_DIR_CACHE.$chemin_cache_session);
 326         }
 327
 328         // $delais par defaut
 329         // pour toutes les pages sans #CACHE{} hors modeles/ et espace privé
 330         // qui sont a cache nul par defaut
 331         if (!isset($GLOBALS['delais'])) {
 332                 define('_DUREE_CACHE_DEFAUT', 24*3600);
 333                 $GLOBALS['delais'] = _DUREE_CACHE_DEFAUT;
 334         }
 335
 336         // determiner la validite de la page
 337         if ($page) {
 338                 $use_cache = cache_valide($page, isset($page['lastmodified']) ? $page['lastmodified'] : 0);
 339                 // le contexte implicite n'est pas stocke dans le cache, mais il y a equivalence
 340                 // par le nom du cache. On le reinjecte donc ici pour utilisation eventuelle au calcul
 341                 $page['contexte_implicite'] = $contexte_implicite;
 342                 if (!$use_cache) {
 343                         // $page est un cache utilisable
 344                         gunzip_page($page);
 345                         return;
 346                 }
 347         } else {
 348                 $page = array('contexte_implicite'=>$contexte_implicite);
 349                 $use_cache = cache_valide($page,0); // fichier cache absent : provoque le calcul
 350         }
 351
 352         // Si pas valide mais pas de connexion a la base, le garder quand meme
 353         if (!spip_connect()) {
 354                 if (isset($page['texte'])) {
 355                         gunzip_page($page);
 356                         $use_cache = 0;
 357                 }
 358                 else {
 359                         spip_log("Erreur base de donnees, impossible utiliser $chemin_cache");
 360                         include_spip('inc/minipres');
 361                         return minipres(_T('info_travaux_titre'),  _T('titre_probleme_technique'));
 362                 }
 363         }
 364
 365         if ($use_cache < 0) $chemin_cache = '';
 366         return;
 367 }
 368
 369 ?>