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

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

Quelques améliorations du code des API

  • Property svn:eol-style set to native
File size: 8.7 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_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_SEPARATEUR', '_');
50}
51
52
53// -----------------------------------------------------------------------
54// ---------------------- SERVICES SURCHARGEABLES ------------------------
55// -----------------------------------------------------------------------
56
57/**
58 * Complète la description d'un type de noisette issue de la lecture de son fichier YAML.
59 *
60 * Le plugin N-Core ne complète pas les types de noisette.
61 *
62 * @uses ncore_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 * @param array  $description
71 *        Description du type de noisette issue de la lecture du fichier YAML. Suivant le plugin utilisateur elle
72 *        nécessite d'être compléter avant son stockage.
73 * @param string $stockage
74 *        Identifiant du service de stockage à utiliser si précisé.
75 *
76 * @return array
77 *        Description du type de noisette éventuellement complétée par le plugin utilisateur.
78 */
79function cache_cache_configurer($plugin) {
80
81        // Initialisation du tableau de configuration avec les valeurs par défaut du plugin Cache.
82        $configuration_defaut = array(
83                'racine'        => _CACHE_RACINE,
84                'nom'           => array('nom'),
85                'extension'     => _CACHE_EXTENSION,
86                'securisation'  => _CACHE_SECURISE,
87                'serialisation' => _CACHE_CONTENU_SERIALISE,
88                'separateur'    => _CACHE_SEPARATEUR
89        );
90
91        // Le plugin utilisateur doit fournir un service propre pour la configuration de ses caches.
92        // Cette configuration peut-être partielle, dans ce cas les données manquantes sont complétées
93        // par celles par défaut.
94        $configuration_plugin = array();
95        if ($configurer = cache_chercher_service($plugin, 'cache_configurer')) {
96                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
97                $configuration_plugin = $configurer($plugin);
98        }
99
100        // On merge la configuration du plugin avec celle par défaut pour assure la complétude.
101        $configuration = array_merge($configuration_defaut, $configuration_plugin);
102
103        // On vérifie l'indicateur de sécurisation : si le cache doit être sécurisé alors son extension
104        // doit absolument être .php. Si ce n'est pas le cas on la force.
105        if ($configuration['securisation']
106        and ($configuration['extension'] != '.php')) {
107                $configuration['extension'] = '.php';
108        }
109
110        // Pour faciliter la construction du chemin des caches on détermine une fois pour toute le dossier
111        // de base des caches du plugin.
112        // -- Vérification de la localisation de la racine qui ne peut être que dans les trois dossiers SPIP
113        //    prévus et de la présence du / final.
114        if (!in_array($configuration['racine'], array(_DIR_CACHE, _DIR_TMP, _DIR_VAR))) {
115                $configuration['racine'] = $configuration_defaut['racine'];
116        } else {
117                $configuration['racine'] = rtrim($configuration['racine'], '/') . '/';
118        }
119        // -- Sous-dossier spécifique au plugin
120        $sous_dossier = ($configuration['racine'] == _DIR_VAR) ? "cache-${plugin}" : "$plugin";
121        // -- Création et enregistrement du dossier de base
122        sous_repertoire($configuration['racine'], $sous_dossier);
123        $configuration['dossier_base'] = $configuration['racine'] . "${sous_dossier}/";
124       
125        // Enregistrement de la configuration du plugin utilisateur dans la meta prévue.
126        // Si une configuration existe déjà on l'écrase.
127        include_spip('inc/config');
128        $meta_cache = lire_config('cache', array());
129        $meta_cache[$plugin] = $configuration;
130        ecrire_config('cache', $meta_cache);
131
132        return $configuration;
133}
134
135
136/**
137 * Construit le chemin complet du fichier cache.
138 *
139 * @api
140 *
141 * @param string $plugin
142 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
143 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
144 * @param array  $conteneur
145 *        Tableau identifiant le cache pour lequel on veut construire le nom.
146 * @param array  $configuration
147 *        Configuration complète des caches du plugin utlisateur.
148 *
149 * @return string
150 */
151function cache_cache_nommer($plugin, $conteneur, $configuration) {
152
153        // Le plugin utilisateur peut fournir un service propre pour construire le chemin complet du fichier cache.
154        // Néanmoins, étant donné la généricité du mécanisme offert par le plugin Cache cela devrait être rare.
155        if ($nommer = cache_chercher_service($plugin, 'cache_nommer')) {
156                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
157                $fichier_cache = $nommer($plugin, $conteneur, $configuration);
158        } else {
159                // On utilise le mécanisme de nommage standard du plugin Cache.
160                // Initialisation du chemin complet du fichier cache
161                $fichier_cache = '';
162
163                // Détermination du répertoire final du fichier cache qui peut-être inclus dans un sous-dossier du dossier
164                // de base des caches du plugin.
165                $dir_cache = $configuration['dossier_base'];
166                if (!empty($conteneur['sous_dossier'])) {
167                        // Si le conteneur nécessite un sous-dossier, appelé service dans l'identifiant du conteneur.
168                        $dir_cache .= rtrim($conteneur['sous_dossier'], '/');
169                }
170
171                // Détermination du nom du cache sans extension.
172                // Celui-ci est construit à partir des éléments fournis sur le conteneur et de la configuration
173                // fournie par le plugin (liste ordonnée de composant).
174                $nom_cache = '';
175                foreach ($configuration['nom'] as $_composant) {
176                        if (isset($conteneur[$_composant])) {
177                                $nom_cache .= ($nom_cache ? $configuration['separateur'] : '') . $conteneur[$_composant];
178                        }
179                }
180
181                // Si le nom a pu être construit on finalise le chemin complet, sinon on renvoie une chaine vide.
182                if ($nom_cache) {
183                        // L'extension par défaut est dans la configuration mais peut-être forcée pour un cache donné.
184                        // Par contre, si le cache est sécurisé alors on ne tient pas compte du forçage éventuel car l'extension
185                        // doit toujours être .php et celle-ci a été forcée lors de la configuration des caches du plugin.
186                        $extension = (!empty($conteneur['extension']) and !$configuration['securisation'])
187                                ? $conteneur['extension']
188                                : $configuration['extension'];
189                        // Le chemin complet
190                        $fichier_cache = "${dir_cache}${nom_cache}${extension}";
191                }
192        }
193
194        return $fichier_cache;
195}
196
197
198// -----------------------------------------------------------------------
199// ----------------- UTILITAIRE PROPRE AU PLUGIN CACHE -------------------
200// -----------------------------------------------------------------------
201
202/**
203 * Cherche une fonction donnée en se basant sur le plugin appelant.
204 * Si le plugin utilisateur ne fournit pas la fonction demandée la chaîne vide est renvoyée.
205 *
206 * @internal
207 *
208 * @param string $plugin
209 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
210 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
211 * @param bool   $fonction
212 *        Nom de la fonction de service à chercher.
213 *
214 * @return string
215 *        Nom complet de la fonction si trouvée ou chaine vide sinon.
216 */
217function cache_chercher_service($plugin, $fonction) {
218
219        $fonction_trouvee = '';
220
221        // Eviter la réentrance si on demande explicitement le service du plugin Cache.
222        if ($plugin != 'cache') {
223                include_spip("cache/${plugin}");
224                $fonction_trouvee = "${plugin}_${fonction}";
225                if (!function_exists($fonction_trouvee)) {
226                        $fonction_trouvee = '';
227                }
228        }
229
230        return $fonction_trouvee;
231}
Note: See TracBrowser for help on using the repository browser.