X-Git-Url: http://git.cyclocoop.org/?a=blobdiff_plain;f=www%2Fecrire%2Fpublic%2Fcacher.php;fp=www%2Fecrire%2Fpublic%2Fcacher.php;h=6602aee3ce0759565a4b9b0f3dd57f4955a86703;hb=52cf8ed924d5dcd0c28dde4b6c3196be6ec2d4f7;hp=0000000000000000000000000000000000000000;hpb=90fe1de0acd20fe72334eb4cc59f300ab705c774;p=ptitvelo%2Fweb%2Fwww.git diff --git a/www/ecrire/public/cacher.php b/www/ecrire/public/cacher.php new file mode 100644 index 0000000..6602aee --- /dev/null +++ b/www/ecrire/public/cacher.php @@ -0,0 +1,369 @@ +$val) { + $val = is_array($val) ? var_export($val,true) : strval($val); + $cache .= str_replace('-', '_', $val) . '-' ; + } + + $cache = str_replace('/', '_', rawurlencode($cache)); + + if (strlen($cache) > 24) { + $cache = preg_replace('/([a-zA-Z]{1,3})[^-_]*[-_]/', '\1-', $cache); + $cache = substr($cache, 0, 24); + } + + // Morceau de md5 selon HOST, $dossier_squelettes et $marqueur + // permet de changer le nom du cache en changeant ceux-ci + // donc, par exemple, de gerer differents dossiers de squelettes + // en parallele, ou de la "personnalisation" via un marqueur (dont la + // composition est totalement libre...) + $md_cache = md5( + var_export($page['contexte_implicite'],true) . ' ' + . var_export($contexte,true) + ); + + $cache .= '-'.substr($md_cache, 1, 32-strlen($cache)); + + // Sous-repertoires 0...9a..f ; ne pas prendre la base _DIR_CACHE + $rep = _DIR_CACHE; + + $rep = sous_repertoire($rep, '', false,true); + $subdir = sous_repertoire($rep, substr($md_cache, 0, 1), true,true); + return $subdir.$cache; +} + +/** + * Faut-il compresser ce cache ? A partir de 16ko ca vaut le coup + * (pas de passage par reference car on veut conserver la version non compressee + * pour l'afficher) + * on positionne un flag gz si on comprime, pour savoir si on doit decompresser ou pas + * http://doc.spip.org/@gzip_page + * + * @param array $page + * @return array + */ +function gzip_page($page) { + if (function_exists('gzcompress') AND strlen($page['texte']) > 16*1024) { + $page['gz'] = true; + $page['texte'] = gzcompress($page['texte']); + } else { + $page['gz'] = false; + } + return $page; +} + +/** + * Faut-il decompresser ce cache ? + * (passage par reference pour alleger) + * on met a jour le flag gz quand on decompresse, pour ne pas risquer + * de decompresser deux fois de suite un cache (ce qui echoue) + * + * http://doc.spip.org/@gunzip_page + * + * @param array $page + * @return void + */ +function gunzip_page(&$page) { + if ($page['gz']) { + $page['texte'] = gzuncompress($page['texte']); + $page['gz'] = false; // ne pas gzuncompress deux fois une meme page + } +} + +/** + * gestion des delais d'expiration du cache... + * $page passee par reference pour accelerer + * + * @param array $page + * @param int $date + * @return int + * 1 si il faut mettre le cache a jour + * 0 si le cache est valide + * -1 si il faut calculer sans stocker en cache + */ +/// http://doc.spip.org/@cache_valide +function cache_valide(&$page, $date) { + + if (defined('_VAR_NOCACHE') AND _VAR_NOCACHE) return -1; + if (isset($GLOBALS['meta']['cache_inhib']) AND $_SERVER['REQUEST_TIME']<$GLOBALS['meta']['cache_inhib']) return -1; + if (defined('_NO_CACHE')) return (_NO_CACHE==0 AND !isset($page['texte']))?1:_NO_CACHE; + if (!$page OR !isset($page['texte']) OR !isset($page['entetes']['X-Spip-Cache'])) return 1; + + // #CACHE{n,statique} => on n'invalide pas avec derniere_modif + // cf. ecrire/public/balises.php, balise_CACHE_dist() + if (!isset($page['entetes']['X-Spip-Statique']) OR $page['entetes']['X-Spip-Statique'] !== 'oui') { + + // Cache invalide par la meta 'derniere_modif' + // sauf pour les bots, qui utilisent toujours le cache + if (!_IS_BOT + AND $GLOBALS['derniere_modif_invalide'] + AND $date < $GLOBALS['meta']['derniere_modif']) + return 1; + + // Apparition d'un nouvel article post-date ? + if ($GLOBALS['meta']['post_dates'] == 'non' + AND isset($GLOBALS['meta']['date_prochain_postdate']) + AND time() > $GLOBALS['meta']['date_prochain_postdate']) { + spip_log('Un article post-date invalide le cache'); + include_spip('inc/rubriques'); + ecrire_meta('derniere_modif', time()); + calculer_prochain_postdate(); + return 1; + } + + } + + // Sinon comparer l'age du fichier a sa duree de cache + $duree = intval($page['entetes']['X-Spip-Cache']); + if ($duree == 0) #CACHE{0} + return -1; + else if ($date + $duree < time()) + return 1; + else + return 0; +} + +/** + * Creer le fichier cache + * Passage par reference de $page par souci d'economie + * + * http://doc.spip.org/@creer_cache + * + * @param array $page + * @param string $chemin_cache + * @return void + */ +function creer_cache(&$page, &$chemin_cache) { + + // Ne rien faire si on est en preview, debug, ou si une erreur + // grave s'est presentee (compilation du squelette, MySQL, etc) + // le cas var_nocache ne devrait jamais arriver ici (securite) + // le cas spip_interdire_cache correspond a une ereur SQL grave non anticipable + if ((defined('_VAR_NOCACHE') AND _VAR_NOCACHE) + OR defined('spip_interdire_cache')) + return; + + // Si la page c1234 a un invalideur de session 'zz', sauver dans + // 'tmp/cache/MD5(chemin_cache)_zz' + if (isset($page['invalideurs']) + AND isset($page['invalideurs']['session'])) { + // on verifie que le contenu du chemin cache indique seulement + // "cache sessionne" ; sa date indique la date de validite + // des caches sessionnes + if (!lire_fichier(_DIR_CACHE . $chemin_cache, $tmp) + OR !$tmp = @unserialize($tmp)) { + spip_log('Creation cache sessionne '.$chemin_cache); + $tmp = array( + 'invalideurs' => array('session' => ''), + 'lastmodified' => time() + ); + ecrire_fichier(_DIR_CACHE . $chemin_cache, serialize($tmp)); + } + $chemin_cache .= '_'.$page['invalideurs']['session']; + } + + // ajouter la date de production dans le cache lui meme + // (qui contient deja sa duree de validite) + $page['lastmodified'] = time(); + + + // l'enregistrer, compresse ou non... + $ok = ecrire_fichier(_DIR_CACHE . $chemin_cache, + serialize(gzip_page($page))); + + spip_log("Creation du cache $chemin_cache pour " + . $page['entetes']['X-Spip-Cache']." secondes". ($ok?'':' (erreur!)')); + + // Inserer ses invalideurs + include_spip('inc/invalideur'); + maj_invalideurs($chemin_cache, $page); + +} + + +/** + * purger un petit cache (tidy ou recherche) qui ne doit pas contenir de + * vieux fichiers ; (cette fonction ne sert que dans des plugins obsoletes) + * + * http://doc.spip.org/@nettoyer_petit_cache + * + * @param string $prefix + * @param int $duree + * @return void + */ +function nettoyer_petit_cache($prefix, $duree = 300) { + // determiner le repertoire a purger : 'tmp/CACHE/rech/' + $dircache = sous_repertoire(_DIR_CACHE,$prefix); + if (spip_touch($dircache.'purger_'.$prefix, $duree, true)) { + foreach (preg_files($dircache,'[.]txt$') as $f) { + if (time() - (@file_exists($f)?@filemtime($f):0) > $duree) + spip_unlink($f); + } + } +} + + +/** + * Interface du gestionnaire de cache + * Si son 3e argument est non vide, elle passe la main a creer_cache + * Sinon, elle recoit un contexte (ou le construit a partir de REQUEST_URI) + * et affecte les 4 autres parametres recus par reference: + * - use_cache qui vaut + * -1 s'il faut calculer la page sans la mettre en cache + * 0 si on peut utiliser un cache existant + * 1 s'il faut calculer la page et la mettre en cache + * - chemin_cache qui est le chemin d'acces au fichier ou vide si pas cachable + * - page qui est le tableau decrivant la page, si le cache la contenait + * - lastmodified qui vaut la date de derniere modif du fichier. + * Elle retourne '' si tout va bien + * un message d'erreur si le calcul de la page est totalement impossible + * + * http://doc.spip.org/@public_cacher_dist + * + * @param array $contexte + * @param int $use_cache + * @param string $chemin_cache + * @param array $page + * @param int $lastmodified + * @return string|void + */ +function public_cacher_dist($contexte, &$use_cache, &$chemin_cache, &$page, &$lastmodified) { + + # fonction de cache minimale : dire "non on ne met rien en cache" + # $use_cache = -1; return; + + // Second appel, destine a l'enregistrement du cache sur le disque + if (isset($chemin_cache)) return creer_cache($page, $chemin_cache); + + // Toute la suite correspond au premier appel + $contexte_implicite = $page['contexte_implicite']; + + // Cas ignorant le cache car completement dynamique + if ($_SERVER['REQUEST_METHOD'] == 'POST' + OR _request('connect')) { + $use_cache = -1; + $lastmodified = 0; + $chemin_cache = ""; + $page = array(); + return; + } + + // Controler l'existence d'un cache nous correspondant + $chemin_cache = generer_nom_fichier_cache($contexte, $page); + $lastmodified = 0; + + // charger le cache s'il existe + if (lire_fichier(_DIR_CACHE . $chemin_cache, $page)) + $page = @unserialize($page); + else + $page = array(); + + // s'il est sessionne, charger celui correspondant a notre session + if (isset($page['invalideurs']) + AND isset($page['invalideurs']['session'])) { + $chemin_cache_session = $chemin_cache . '_' . spip_session(); + if (lire_fichier(_DIR_CACHE . $chemin_cache_session, $page_session) + AND $page_session = @unserialize($page_session) + AND $page_session['lastmodified'] >= $page['lastmodified']) + $page = $page_session; + else + $page = array(); + } + + + // Faut-il effacer des pages invalidees (en particulier ce cache-ci) ? + if (isset($GLOBALS['meta']['invalider'])) { + // ne le faire que si la base est disponible + if (spip_connect()) { + include_spip('inc/invalideur'); + retire_caches($chemin_cache); # API invalideur inutile + supprimer_fichier(_DIR_CACHE.$chemin_cache); + if (isset($chemin_cache_session) and $chemin_cache_session) + supprimer_fichier(_DIR_CACHE.$chemin_cache_session); + } + } + + // Si un calcul, recalcul [ou preview, mais c'est recalcul] est demande, + // on supprime le cache + if (defined('_VAR_MODE') && _VAR_MODE && + (isset($_COOKIE['spip_session']) + || isset($_COOKIE['spip_admin']) + || @file_exists(_ACCESS_FILE_NAME)) + ) { + $page = array('contexte_implicite'=>$contexte_implicite); // ignorer le cache deja lu + include_spip('inc/invalideur'); + retire_caches($chemin_cache); # API invalideur inutile + supprimer_fichier(_DIR_CACHE.$chemin_cache); + if (isset($chemin_cache_session) and $chemin_cache_session) + supprimer_fichier(_DIR_CACHE.$chemin_cache_session); + } + + // $delais par defaut + // pour toutes les pages sans #CACHE{} hors modeles/ et espace privé + // qui sont a cache nul par defaut + if (!isset($GLOBALS['delais'])) { + define('_DUREE_CACHE_DEFAUT', 24*3600); + $GLOBALS['delais'] = _DUREE_CACHE_DEFAUT; + } + + // determiner la validite de la page + if ($page) { + $use_cache = cache_valide($page, isset($page['lastmodified']) ? $page['lastmodified'] : 0); + // le contexte implicite n'est pas stocke dans le cache, mais il y a equivalence + // par le nom du cache. On le reinjecte donc ici pour utilisation eventuelle au calcul + $page['contexte_implicite'] = $contexte_implicite; + if (!$use_cache) { + // $page est un cache utilisable + gunzip_page($page); + return; + } + } else { + $page = array('contexte_implicite'=>$contexte_implicite); + $use_cache = cache_valide($page,0); // fichier cache absent : provoque le calcul + } + + // Si pas valide mais pas de connexion a la base, le garder quand meme + if (!spip_connect()) { + if (isset($page['texte'])) { + gunzip_page($page); + $use_cache = 0; + } + else { + spip_log("Erreur base de donnees, impossible utiliser $chemin_cache"); + include_spip('inc/minipres'); + return minipres(_T('info_travaux_titre'), _T('titre_probleme_technique')); + } + } + + if ($use_cache < 0) $chemin_cache = ''; + return; +} + +?>