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

Last change on this file since 113748 was 113748, checked in by eric@…, 20 months ago

Renommage et PHPDoc

  • 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.
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         * Dossier racine dans lesquels tous les caches par défaut seront rangés.
47         * Les caches sont répartis suivant le plugin appelant dans un sous-dossier `/${plugin}`.
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                $configuration['racine'] = rtrim($configuration['racine'], '/') . '/';
113        }
114        // -- Sous-dossier spécifique au plugin
115        $sous_dossier = ($configuration['racine'] == _DIR_VAR) ? "cache-${plugin}" : "$plugin";
116        // -- Création et enregistrement du dossier de base
117        sous_repertoire($configuration['racine'], $sous_dossier);
118        $configuration['dossier_base'] = $configuration['racine'] . "${sous_dossier}/";
119       
120        // Enregistrement de la configuration du plugin utilisateur dans la meta prévue.
121        // Si une configuration existe déjà on l'écrase.
122        include_spip('inc/config');
123        $meta_cache = lire_config('cache', array());
124        $meta_cache[$plugin] = $configuration;
125        ecrire_config('cache', $meta_cache);
126
127        return $configuration;
128}
129
130
131/**
132 * Construit le chemin complet du fichier cache.
133 *
134 * @uses cache_chercher_service()
135 *
136 * @param string $plugin
137 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
138 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
139 * @param array  $cache
140 *        Tableau identifiant le cache pour lequel on veut construire le nom.
141 * @param array  $configuration
142 *        Configuration complète des caches du plugin utlisateur lue à partir de la meta de stockage.
143 *
144 * @return string
145 */
146function cache_cache_nommer($plugin, $cache, $configuration) {
147
148        // Le plugin utilisateur peut fournir un service propre pour construire le chemin complet du fichier cache.
149        // Néanmoins, étant donné la généricité du mécanisme offert par le plugin Cache cela devrait être rare.
150        if ($nommer = cache_chercher_service($plugin, 'cache_nommer')) {
151                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
152                $fichier_cache = $nommer($plugin, $cache, $configuration);
153        } else {
154                // On utilise le mécanisme de nommage standard du plugin Cache.
155                // Initialisation du chemin complet du fichier cache
156                $fichier_cache = '';
157
158                // Détermination du répertoire final du fichier cache qui peut-être inclus dans un sous-dossier du dossier
159                // de base des caches du plugin.
160                $dir_cache = $configuration['dossier_base'];
161                if (!empty($cache['sous_dossier'])) {
162                        // Si le cache nécessite un sous-dossier, appelé service dans l'identifiant du cache.
163                        $dir_cache .= rtrim($cache['sous_dossier'], '/');
164                }
165
166                // Détermination du nom du cache sans extension.
167                // Celui-ci est construit à partir des éléments fournis sur le cache et de la configuration
168                // fournie par le plugin (liste ordonnée de composant).
169                $nom_cache = '';
170                foreach ($configuration['nom'] as $_composant) {
171                        if (isset($cache[$_composant])) {
172                                $nom_cache .= ($nom_cache ? $configuration['separateur'] : '') . $cache[$_composant];
173                        }
174                }
175
176                // Si le nom a pu être construit on finalise le chemin complet, sinon on renvoie une chaine vide.
177                if ($nom_cache) {
178                        // L'extension par défaut est dans la configuration mais peut-être forcée pour un cache donné.
179                        // Par contre, si le cache est sécurisé alors on ne tient pas compte du forçage éventuel car l'extension
180                        // doit toujours être .php et celle-ci a été forcée lors de la configuration des caches du plugin.
181                        $extension = (!empty($cache['extension']) and !$configuration['securisation'])
182                                ? $cache['extension']
183                                : $configuration['extension'];
184                        // Le chemin complet
185                        $fichier_cache = "${dir_cache}${nom_cache}${extension}";
186                }
187        }
188
189        return $fichier_cache;
190}
191
192
193// -----------------------------------------------------------------------
194// ----------------- UTILITAIRE PROPRE AU PLUGIN CACHE -------------------
195// -----------------------------------------------------------------------
196
197/**
198 * Cherche une fonction donnée en se basant sur le plugin appelant.
199 * Si le plugin utilisateur ne fournit pas la fonction demandée la chaîne vide est renvoyée.
200 *
201 * @internal
202 *
203 * @param string $plugin
204 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
205 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
206 * @param bool   $fonction
207 *        Nom de la fonction de service à chercher.
208 *
209 * @return string
210 *        Nom complet de la fonction si trouvée ou chaine vide sinon.
211 */
212function cache_chercher_service($plugin, $fonction) {
213
214        $fonction_trouvee = '';
215
216        // Eviter la réentrance si on demande explicitement le service du plugin Cache.
217        if ($plugin != 'cache') {
218                include_spip("cache/${plugin}");
219                $fonction_trouvee = "${plugin}_${fonction}";
220                if (!function_exists($fonction_trouvee)) {
221                        $fonction_trouvee = '';
222                }
223        }
224
225        return $fonction_trouvee;
226}
Note: See TracBrowser for help on using the repository browser.