source: spip-zone/_plugins_/cache/trunk/cache/cache.php @ 113780

Last change on this file since 113780 was 113780, checked in by root, 4 months ago

Quelques corrections, simplifications et renommages

  • Property svn:eol-style set to native
File size: 8.5 KB
Line 
1<?php
2/**
3 * Ce fichier contient les fonctions de service du plugin Cache.
4 *
5 * Chaque fonction, soit aiguille, si elle existe, vers une fonction "homonyme" propre au plugin appelant
6 * soit déroule sa propre implémentation.
7 * Ainsi, les plugins externes peuvent, si elle leur convient, utiliser l'implémentation proposée par Cache Factory.
8 *
9 * @package SPIP\CACHE\SERVICE
10 */
11if (!defined('_ECRIRE_INC_VERSION')) {
12        return;
13}
14
15if (!defined('_CACHE_RACINE')) {
16        /**
17         * Dossier racine dans lesquels tous les caches par défaut seront rangés.
18         * Les caches sont répartis suivant le plugin appelant dans un sous-dossier `/${plugin}`.
19         */
20        define('_CACHE_RACINE', _DIR_CACHE);
21}
22
23if (!defined('_CACHE_EXTENSION')) {
24        /**
25         * Extension par défaut d'un cache.
26         */
27        define('_CACHE_EXTENSION', '.txt');
28}
29
30if (!defined('_CACHE_SECURISE')) {
31        /**
32         * Extension par défaut d'un cache.
33         */
34        define('_CACHE_SECURISE', false);
35}
36
37if (!defined('_CACHE_CONTENU_SERIALISE')) {
38        /**
39         * Extension par défaut d'un cache.
40         */
41        define('_CACHE_CONTENU_SERIALISE', true);
42}
43
44if (!defined('_CACHE_NOM_SEPARATEUR')) {
45        /**
46         * Caractère séparateur des composants du nom d'un fichier cache.
47         * De fait, ce caractère ne doit pas être utilisé dans les composants.
48         */
49        define('_CACHE_NOM_SEPARATEUR', '_');
50}
51
52
53// -----------------------------------------------------------------------
54// ---------------------- SERVICES SURCHARGEABLES ------------------------
55// -----------------------------------------------------------------------
56
57/**
58 * Récupère la configuration des caches d'un plugin, la complète et la stocke dans une meta.
59 *
60 * Le plugin Cache Factory propose une configuration par défaut des caches.
61 *
62 * @uses cache_chercher_service()
63 * @uses sous_repertoire()
64 * @uses lire_config()
65 * @uses ecrire_config()
66 *
67 * @param string $plugin
68 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
69 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
70 *
71 * @return array
72 *        Tableau de la configuration complétée des caches d'un plugin venant d'être enregistrée.
73 */
74function cache_cache_configurer($plugin) {
75
76        // Initialisation du tableau de configuration avec les valeurs par défaut du plugin Cache.
77        $configuration_defaut = array(
78                'racine'        => _CACHE_RACINE,
79                'nom'           => array('nom'),
80                'extension'     => _CACHE_EXTENSION,
81                'securisation'  => _CACHE_SECURISE,
82                'serialisation' => _CACHE_CONTENU_SERIALISE,
83                'separateur'    => _CACHE_NOM_SEPARATEUR
84        );
85
86        // Le plugin utilisateur doit fournir un service propre pour la configuration de ses caches.
87        // Cette configuration peut-être partielle, dans ce cas les données manquantes sont complétées
88        // par celles par défaut.
89        $configuration_plugin = array();
90        if ($configurer = cache_chercher_service($plugin, 'cache_configurer')) {
91                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
92                $configuration_plugin = $configurer($plugin);
93        }
94
95        // On merge la configuration du plugin avec celle par défaut pour assure la complétude.
96        $configuration = array_merge($configuration_defaut, $configuration_plugin);
97
98        // On vérifie l'indicateur de sécurisation : si le cache doit être sécurisé alors son extension
99        // doit absolument être .php. Si ce n'est pas le cas on la force.
100        if ($configuration['securisation']
101        and ($configuration['extension'] != '.php')) {
102                $configuration['extension'] = '.php';
103        }
104
105        // Pour faciliter la construction du chemin des caches on détermine une fois pour toute le dossier
106        // de base des caches du plugin.
107        // -- Vérification de la localisation de la racine qui ne peut être que dans les trois dossiers SPIP
108        //    prévus et de la présence du / final.
109        if (!in_array($configuration['racine'], array(_DIR_CACHE, _DIR_TMP, _DIR_VAR))) {
110                $configuration['racine'] = $configuration_defaut['racine'];
111        } else {
112                // On s'assure que la racine se termine toujours par un slash.
113                $configuration['racine'] = rtrim($configuration['racine'], '/') . '/';
114        }
115        // -- Sous-dossier spécifique au plugin
116        $sous_dossier = ($configuration['racine'] == _DIR_VAR) ? "cache-${plugin}" : "$plugin";
117        // -- Création et enregistrement du dossier de base
118        include_spip('inc/flock');
119        $configuration['dossier_base'] = sous_repertoire($configuration['racine'], $sous_dossier);
120       
121        // Enregistrement de la configuration du plugin utilisateur dans la meta prévue.
122        // Si une configuration existe déjà on l'écrase.
123        include_spip('inc/config');
124        $meta_cache = lire_config('cache', array());
125        $meta_cache[$plugin] = $configuration;
126        ecrire_config('cache', $meta_cache);
127
128        return $configuration;
129}
130
131
132/**
133 * Construit le chemin complet du fichier cache.
134 *
135 * @uses cache_chercher_service()
136 *
137 * @param string $plugin
138 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
139 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
140 * @param array  $cache
141 *        Tableau identifiant le cache pour lequel on veut construire le nom.
142 * @param array  $configuration
143 *        Configuration complète des caches du plugin utlisateur lue à partir de la meta de stockage.
144 *
145 * @return string
146 */
147function cache_cache_composer($plugin, $cache, $configuration) {
148
149        // Le plugin utilisateur peut fournir un service propre pour construire le chemin complet du fichier cache.
150        // Néanmoins, étant donné la généricité du mécanisme offert par le plugin Cache cela devrait être rare.
151        if ($nommer = cache_chercher_service($plugin, 'cache_nommer')) {
152                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
153                $fichier_cache = $nommer($plugin, $cache, $configuration);
154        } else {
155                // On utilise le mécanisme de nommage standard du plugin Cache.
156                // Initialisation du chemin complet du fichier cache
157                $fichier_cache = '';
158
159                // Détermination du répertoire final du fichier cache qui peut-être inclus dans un sous-dossier du dossier
160                // de base des caches du plugin.
161                $dir_cache = $configuration['dossier_base'];
162                if (!empty($cache['sous_dossier'])) {
163                        // Si le cache nécessite un sous-dossier, appelé service dans l'identifiant du cache.
164                        $dir_cache .= rtrim($cache['sous_dossier'], '/') . '/';
165                }
166
167                // Détermination du nom du cache sans extension.
168                // Celui-ci est construit à partir des éléments fournis sur le cache et de la configuration
169                // fournie par le plugin (liste ordonnée de composant).
170                $nom_cache = '';
171                foreach ($configuration['nom'] as $_composant) {
172                        if (isset($cache[$_composant])) {
173                                $nom_cache .= ($nom_cache ? $configuration['separateur'] : '') . $cache[$_composant];
174                        }
175                }
176
177                // Si le nom a pu être construit on finalise le chemin complet, sinon on renvoie une chaine vide.
178                if ($nom_cache) {
179                        // L'extension par défaut est dans la configuration mais peut-être forcée pour un cache donné.
180                        // Par contre, si le cache est sécurisé alors on ne tient pas compte du forçage éventuel car l'extension
181                        // doit toujours être .php et celle-ci a été forcée lors de la configuration des caches du plugin.
182                        $extension = (!empty($cache['extension']) and !$configuration['securisation'])
183                                ? $cache['extension']
184                                : $configuration['extension'];
185                        // Le chemin complet
186                        $fichier_cache = "${dir_cache}${nom_cache}${extension}";
187                }
188        }
189
190        return $fichier_cache;
191}
192
193
194// -----------------------------------------------------------------------
195// ----------------- UTILITAIRE PROPRE AU PLUGIN CACHE -------------------
196// -----------------------------------------------------------------------
197
198/**
199 * Cherche une fonction donnée en se basant sur le plugin appelant.
200 * Si le plugin utilisateur ne fournit pas la fonction demandée la chaîne vide est renvoyée.
201 *
202 * @internal
203 *
204 * @param string $plugin
205 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
206 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
207 * @param bool   $fonction
208 *        Nom de la fonction de service à chercher.
209 *
210 * @return string
211 *        Nom complet de la fonction si trouvée ou chaine vide sinon.
212 */
213function cache_chercher_service($plugin, $fonction) {
214
215        $fonction_trouvee = '';
216
217        // Eviter la réentrance si on demande explicitement le service du plugin Cache.
218        if ($plugin != 'cache') {
219                include_spip("cache/${plugin}");
220                $fonction_trouvee = "${plugin}_${fonction}";
221                if (!function_exists($fonction_trouvee)) {
222                        $fonction_trouvee = '';
223                }
224        }
225
226        return $fonction_trouvee;
227}
Note: See TracBrowser for help on using the repository browser.