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

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

Pétouilles

  • Property svn:eol-style set to native
File size: 13.0 KB
Line 
1<?php
2/**
3 * Ce fichier contient les fonctions d'API du plugin Cache Factory.
4 *
5 * @package SPIP\CACHE\API
6 */
7if (!defined('_ECRIRE_INC_VERSION')) {
8        return;
9}
10
11
12/**
13 * Ecrit un contenu dans un cache spécifié par son identifiant.
14 *
15 * @api
16 *
17 * @uses cache_configuration_lire()
18 * @uses cache_cache_configurer()
19 * @uses cache_cache_composer()
20 *
21 * @param string       $plugin
22 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
23 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
24 * @param array|string $cache
25 *        Identifiant du cache sous la forme d'une chaine (le chemin du fichier) ou d'un tableau fournissant
26 *        les composants canoniques du nom.
27 * @param array|string $contenu
28 *        Contenu sous forme de tableau à sérialiser ou sous la forme d'une chaine.
29 *
30 * @return bool
31 *         True si l'écriture s'est bien passée, false sinon.
32 */
33function cache_ecrire($plugin, $cache, $contenu) {
34
35        // Initialisation du retour de la fonction
36        $cache_ecrit = false;
37       
38        // Lecture de la configuration des caches du plugin.
39        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel).
40        static $configuration = array();
41        include_spip('cache/cache');
42        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
43                $configuration[$plugin] = cache_cache_configurer($plugin);
44        }
45       
46        // Le cache peut-être fourni soit sous la forme d'un chemin complet soit sous la forme d'un
47        // tableau permettant de calculer le chemin complet. On prend en compte ces deux cas.
48        $fichier_cache = '';
49        include_spip('inc/flock');
50        if (is_array($cache)) {
51                // Création du répertoire du cache à créer, si besoin.
52                if (!empty($cache['sous_dossier'])) {
53                        // Si le conteneur nécessite un sous-dossier, appelé service dans l'identifiant du conteneur.
54                        sous_repertoire($configuration[$plugin]['dossier_base'], rtrim($cache['sous_dossier'], '/'));
55                }
56
57                // Détermination du chemin du cache :
58                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
59                //   de la configuration du nom pour le plugin.
60                $fichier_cache = cache_cache_composer($plugin, $cache, $configuration[$plugin]);
61        } elseif (is_string($cache)) {
62                // Le chemin complet du fichier cache est fourni. Aucune vérification ne peut être faite
63                // il faut donc que l'appelant ait utilisé l'API pour calculer le fichier au préalable.
64                $fichier_cache = $cache;
65        }
66       
67        if ($fichier_cache) {
68                // Suivant que la configuration demande une sérialisation ou pas, on vérife le format du contenu
69                // de façon à toujours écrire une chaine.
70                $contenu_cache = '';
71                if ($configuration[$plugin]['serialisation']) {
72                        if (!is_array($contenu)) {
73                                $contenu = $contenu ? array($contenu) : array();
74                        }
75                        $contenu_cache = serialize($contenu);
76                } else {
77                        if (is_string($contenu)) {
78                                $contenu_cache = $contenu;
79                        }
80                }
81
82                // Ecriture du fichier cache sécurisé ou pas suivant la configuration.
83                $ecrire = 'ecrire_fichier';
84                if ($configuration[$plugin]['securisation']) {
85                        $ecrire = 'ecrire_fichier_securise';
86                }
87                $cache_ecrit = $ecrire($fichier_cache, $contenu_cache);
88        }
89       
90        return $cache_ecrit;
91}
92
93
94/**
95 * Lit le cache spécifié par son identifiant et renvoie le contenu sous forme de tableau
96 * ou de chaine éventuellement vide.
97 *
98 * @api
99 *
100 * @uses cache_configuration_lire()
101 * @uses cache_cache_configurer()
102 * @uses cache_cache_composer()
103 *
104 * @param string       $plugin
105 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
106 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
107 * @param array|string $cache
108 *        Identifiant du cache sous la forme d'une chaine (le chemin du fichier) ou d'un tableau fournissant
109 *        les composants canoniques du nom.
110 *
111 * @return array|string|bool
112 *        Contenu du fichier sous la forme d'un tableau, d'une chaine ou false si une erreur s'est produite.
113 */
114function cache_lire($plugin, $cache) {
115
116        // Initialisation du contenu du cache
117        $cache_lu = false;
118       
119        // Lecture de la configuration des caches du plugin.
120        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel, peu probable pour une lecture).
121        static $configuration = array();
122        include_spip('cache/cache');
123        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
124                $configuration[$plugin] = cache_cache_configurer($plugin);
125        }
126
127        // Le cache peut-être fourni soit sous la forme d'un chemin complet soit sous la forme d'un
128        // tableau permettant de calculer le chemin complet. On prend en compte ces deux cas.
129        $fichier_cache = '';
130        if (is_array($cache)) {
131                // Détermination du chemin du cache :
132                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
133                //   de la configuration du nom pour le plugin.
134                $fichier_cache = cache_cache_composer($plugin, $cache, $configuration[$plugin]);
135        } elseif (is_string($cache)) {
136                // Le chemin complet du fichier cache est fourni. Aucune vérification ne peut être faite
137                // il faut donc que l'appelant ait utilisé l'API pour calculer le fichier au préalable.
138                $fichier_cache = $cache;
139        }
140
141        // Détermination du nom du cache en fonction du plugin appelant et du type
142        if ($fichier_cache) {
143                // Lecture du fichier cache sécurisé ou pas suivant la configuration.
144                include_spip('inc/flock');
145                $lire = 'lire_fichier';
146                if ($configuration[$plugin]['securisation']) {
147                        $lire = 'lire_fichier_securise';
148                }
149                $contenu_cache = '';
150                $lecture_ok = $lire($fichier_cache, $contenu_cache);
151               
152                if ($lecture_ok) {
153                        if ($configuration[$plugin]['serialisation']) {
154                                $cache_lu = unserialize($contenu_cache);
155                        } else {
156                                $cache_lu = $contenu_cache;
157                        }
158                }
159        }
160
161        return $cache_lu;
162}
163
164
165/**
166 * Teste l'existence d'un cache sur le disque et, si il existe, renvoie le chemin complet.
167 *
168 * @api
169 *
170 * @uses cache_configuration_lire()
171 * @uses cache_cache_configurer()
172 * @uses cache_cache_composer()
173 *
174 * @param string       $plugin
175 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
176 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
177 * @param array|string $cache
178 *        Identifiant du cache sous la forme d'une chaine (le chemin du fichier) ou d'un tableau fournissant
179 *        les composants canoniques du nom.
180 *
181 * @return string
182 */
183function cache_existe($plugin, $cache) {
184
185        // Lecture de la configuration des caches du plugin.
186        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel).
187        static $configuration = array();
188        include_spip('cache/cache');
189        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
190                $configuration[$plugin] = cache_cache_configurer($plugin);
191        }
192
193        // Le cache peut-être fourni soit sous la forme d'un chemin complet soit sous la forme d'un
194        // tableau permettant de calculer le chemin complet. On prend en compte ces deux cas.
195        $fichier_cache = '';
196        if (is_array($cache)) {
197                // Détermination du chemin du cache :
198                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
199                //   de la configuration du nom pour le plugin.
200                $fichier_cache = cache_cache_composer($plugin, $cache, $configuration[$plugin]);
201        } elseif (is_string($cache)) {
202                // Le chemin complet du fichier cache est fourni. Aucune vérification ne peut être faite
203                // il faut donc que l'appelant ait utilisé l'API cache_existe() pour calculer le fichier au préalable.
204                $fichier_cache = $cache;
205        }
206
207        // Vérifier l'existence du fichier.
208        if ($fichier_cache) {
209                if (!file_exists($fichier_cache)) {
210                        $fichier_cache = '';
211                }
212        }
213
214        return $fichier_cache;
215}
216
217
218/**
219 * Renvoie le chemin complet du cache sans tester son existence.
220 * Cette fonction est une encapsulation du service cache_cache_composer().
221 *
222 * @api
223 *
224 * @uses cache_configuration_lire()
225 * @uses cache_cache_configurer()
226 * @uses cache_cache_composer()
227 *
228 * @param string $plugin
229 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
230 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
231 * @param array  $cache
232 *        Identifiant du cache sous la forme d'un tableau fournissant les composants canoniques du nom.
233 *
234 * @return string
235 */
236function cache_nommer($plugin, $cache) {
237
238        // Lecture de la configuration des caches du plugin.
239        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel).
240        static $configuration = array();
241        include_spip('cache/cache');
242        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
243                $configuration[$plugin] = cache_cache_configurer($plugin);
244        }
245
246        // Le cache est toujours fourni sous la forme d'un tableau permettant de calculer le chemin complet.
247        $fichier_cache = '';
248        if (is_array($cache)) {
249                // Détermination du chemin du cache :
250                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
251                //   de la configuration du nom pour le plugin.
252                $fichier_cache = cache_cache_composer($plugin, $cache, $configuration[$plugin]);
253        }
254
255        return $fichier_cache;
256}
257
258
259/**
260 * Supprime le cache spécifié par son identifiant.
261 *
262 * @api
263 *
264 * @uses cache_configuration_lire()
265 * @uses cache_cache_configurer()
266 * @uses cache_cache_composer()
267 * @uses supprimer_fichier()
268 *
269 * @param string       $plugin
270 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
271 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
272 * @param array|string $cache
273 *        Identifiant du cache sous la forme d'une chaine (le chemin du fichier) ou d'un tableau fournissant
274 *        les composants canoniques du nom.
275 *
276 * @return bool
277 *         True si la suppression s'est bien passée, false sinon.
278 */
279function cache_supprimer($plugin, $cache) {
280
281        // Initialisation du contenu du cache
282        $cache_supprime = false;
283       
284        // Lecture de la configuration des caches du plugin.
285        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel, peu probable pour une lecture).
286        static $configuration = array();
287        include_spip('cache/cache');
288        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
289                $configuration[$plugin] = cache_cache_configurer($plugin);
290        }
291
292        // Le cache peut-être fourni soit sous la forme d'un chemin complet soit sous la forme d'un
293        // tableau permettant de calculer le chemin complet. On prend en compte ces deux cas.
294        $fichier_cache = '';
295        if (is_array($cache)) {
296                // Détermination du chemin du cache :
297                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
298                //   de la configuration du nom pour le plugin.
299                $fichier_cache = cache_cache_composer($plugin, $cache, $configuration[$plugin]);
300        } elseif (is_string($cache)) {
301                // Le chemin complet du fichier cache est fourni. Aucune vérification ne peut être faite
302                // il faut donc que l'appelant ait utilisé l'API cache_existe() pour calculer le fichier au préalable.
303                $fichier_cache = $cache;
304        }
305
306        // Détermination du nom du cache en fonction du plugin appelant et du type
307        if ($fichier_cache) {
308                // Lecture du fichier cache sécurisé ou pas suivant la configuration.
309                include_spip('inc/flock');
310                $cache_supprime = supprimer_fichier($fichier_cache);
311        }
312
313        return $cache_supprime;
314}
315
316
317/**
318 * Supprime le ou les caches spécifiés d'un plugin donné.
319 * A AMELIORER
320 *
321 * @api
322 *
323 * @param string $plugin
324 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
325 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
326 * @param array  $caches
327 *        Liste des fichiers caches (chemin complet) à supprimer.
328 *
329 * @return bool
330 */
331function cache_vider($plugin, $caches) {
332
333        // Initialisation du retour
334        $cache_vide = false;
335
336        if ($caches) {
337                $fichiers_cache = is_string($caches) ? array($caches) : $caches;
338                include_spip('inc/flock');
339                foreach ($fichiers_cache as $_fichier) {
340                        supprimer_fichier($_fichier);
341                }
342                $cache_vide = true;
343        }
344       
345        return $cache_vide;
346}
347
348
349/**
350 * Lit la configuration standard des caches d'un plugin utilisateur.
351 *
352 * @api
353 *
354 * @uses lire_config()
355 *
356 * @param string $plugin
357 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
358 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
359 *
360 * @return array
361 *        Tableau de configuration des caches d'un plugin utilisateur ou tableau vide si aucune configuration n'est encore
362 *        enregistrée.
363 */
364function cache_configuration_lire($plugin) {
365
366        // Initialisation de la configuration à retourner
367        $configuration_lue = array();
368
369        if ($plugin) {
370                // Récupération de la meta du plugin Cache
371                include_spip('inc/config');
372                $configuration_lue = lire_config("cache/${plugin}", array());
373        }
374
375        return $configuration_lue;
376}
Note: See TracBrowser for help on using the repository browser.