Changeset 113744 in spip-zone


Ignore:
Timestamp:
Feb 5, 2019, 12:33:12 PM (4 months ago)
Author:
eric@…
Message:

Quelques améliorations du code des API

Location:
_plugins_/cache/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/cache/trunk/cache/cache.php

    r113742 r113744  
    8989        );
    9090
    91         // Si le plugin utilisateur complète la description avec des champs spécifiques il doit proposer un service
    92         // de complément propre.
     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.
    9394        $configuration_plugin = array();
    9495        if ($configurer = cache_chercher_service($plugin, 'cache_configurer')) {
     
    9899
    99100        // On merge la configuration du plugin avec celle par défaut pour assure la complétude.
    100         $configuration_plugin = array_merge($configuration_defaut, $configuration_plugin);
     101        $configuration = array_merge($configuration_defaut, $configuration_plugin);
    101102
    102103        // On vérifie l'indicateur de sécurisation : si le cache doit être sécurisé alors son extension
    103104        // doit absolument être .php. Si ce n'est pas le cas on la force.
    104         if ($configuration_plugin['securisation']
    105         and ($configuration_plugin['extension'] != '.php')) {
    106                 $configuration_plugin['extension'] = '.php';
     105        if ($configuration['securisation']
     106        and ($configuration['extension'] != '.php')) {
     107                $configuration['extension'] = '.php';
    107108        }
    108109
     
    111112        // -- Vérification de la localisation de la racine qui ne peut être que dans les trois dossiers SPIP
    112113        //    prévus et de la présence du / final.
    113         if (!in_array($configuration_plugin['racine'], array(_DIR_CACHE, _DIR_TMP, _DIR_VAR))) {
    114                 $configuration_plugin['racine'] = $configuration_defaut['racine'];
     114        if (!in_array($configuration['racine'], array(_DIR_CACHE, _DIR_TMP, _DIR_VAR))) {
     115                $configuration['racine'] = $configuration_defaut['racine'];
    115116        } else {
    116                 $configuration_plugin['racine'] = rtrim($configuration_plugin['racine'], '/') . '/';
     117                $configuration['racine'] = rtrim($configuration['racine'], '/') . '/';
    117118        }
    118119        // -- Sous-dossier spécifique au plugin
    119         $sous_dossier = ($configuration_plugin['racine'] == _DIR_VAR) ? "cache-${plugin}" : "$plugin";
     120        $sous_dossier = ($configuration['racine'] == _DIR_VAR) ? "cache-${plugin}" : "$plugin";
    120121        // -- Création et enregistrement du dossier de base
    121         sous_repertoire($configuration_plugin['racine'], $sous_dossier);
    122         $configuration['dossier_base'] = $configuration_plugin['racine'] . "${sous_dossier}/";
     122        sous_repertoire($configuration['racine'], $sous_dossier);
     123        $configuration['dossier_base'] = $configuration['racine'] . "${sous_dossier}/";
    123124       
    124125        // Enregistrement de la configuration du plugin utilisateur dans la meta prévue.
     
    129130        ecrire_config('cache', $meta_cache);
    130131
    131         return $configuration_plugin;
     132        return $configuration;
    132133}
    133134
     
    148149 * @return string
    149150 */
    150 function cache_cache_nommer_dist($plugin, $conteneur, $configuration) {
    151 
    152         // Initialisation du chemin complet du fichier cache
    153         $fichier_cache = '';
    154 
    155         // Détermination du répertoire final du fichier cache qui peut-être inclus dans un sous-dossier du dossier
    156         // de base des caches du plugin.
    157         $dir_cache = $configuration['dossier_base'];
    158         if (!empty($conteneur['sous_dossier'])) {
    159                 // Si le conteneur nécessite un sous-dossier, appelé service dans l'identifiant du conteneur.
    160                 $dir_cache .= rtrim($conteneur['sous_dossier'], '/');
    161         }
    162 
    163         // Détermination du nom du cache sans extension.
    164         // Celui-ci est construit à partir des éléments fournis sur le conteneur et de la configuration
    165         // fournie par le plugin (liste ordonnée de composant).
    166         $nom_cache = '';
    167         foreach ($configuration['nom'] as $_composant) {
    168                 if (isset($conteneur[$_composant])) {
    169                         $nom_cache .= ($nom_cache ? $configuration['separateur'] : '') . $conteneur[$_composant];
    170                 }
    171         }
    172 
    173         // Si le nom a pu être construit on finalise le chemin complet, sinon on renvoie une chaine vide.
    174         if ($nom_cache) {
    175                 // L'extension par défaut est dans la configuration mais peut-être forcée pour un cache donné.
    176                 // Par contre, si le cache est sécurisé alors on ne tient pas compte du forçage éventuel car l'extension
    177                 // doit toujours être .php et celle-ci a été forcée lors de la configuration des caches du plugin.
    178                 $extension = (!empty($conteneur['extension']) and !$configuration['securisation'])
    179                         ? $conteneur['extension']
    180                         : $configuration['extension'];
    181                 // Le chemin complet
    182                 $fichier_cache = "${dir_cache}${nom_cache}${extension}";
     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                }
    183192        }
    184193
  • _plugins_/cache/trunk/inc/cache_api.php

    r113742 r113744  
    1818 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    1919 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    20  * @param array  $conteneur
     20 * @param array|string  $cache
    2121 *        Nom et extension du fichier cache.
    2222 * @param array  $contenu
     
    2525 * @return bool
    2626 */
    27 function cache_ecrire($plugin, $conteneur, $contenu) {
     27function cache_ecrire($plugin, $cache, $contenu) {
    2828
    2929        // Initialisation du retour de la fonction
     
    3333        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel).
    3434        static $configuration = array();
    35         if (!$configuration and (!$configuration = cache_configuration_lire($plugin))) {
    36                 $configuration = cache_cache_configurer($plugin);
    37         }
    38        
    39         // Création du répertoire du cache à créer, si besoin.
    40         if (!empty($conteneur['sous_dossier'])) {
    41                 // Si le conteneur nécessite un sous-dossier, appelé service dans l'identifiant du conteneur.
    42                 sous_repertoire($configuration['dossier_base'], rtrim($conteneur['sous_dossier'], '/'));
    43         }
    44 
    45         // Détermination du chemin du cache :
    46         // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
    47         //   de la configuration du nom pour le plugin.
    48         if ($fichier_cache = cache_nommer($plugin, $conteneur, $configuration)) {
     35        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
     36                $configuration[$plugin] = cache_cache_configurer($plugin);
     37        }
     38       
     39        // Le cache peut-être fourni soit sous la forme d'un chemin complet soit sous la forme d'un
     40        // tableau permettant de calculer le chemin complet. On prend en compte ces deux cas.
     41        $fichier_cache = '';
     42        if (is_array($cache)) {
     43                // Création du répertoire du cache à créer, si besoin.
     44                if (!empty($cache['sous_dossier'])) {
     45                        // Si le conteneur nécessite un sous-dossier, appelé service dans l'identifiant du conteneur.
     46                        sous_repertoire($configuration[$plugin]['dossier_base'], rtrim($cache['sous_dossier'], '/'));
     47                }
     48
     49                // Détermination du chemin du cache :
     50                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
     51                //   de la configuration du nom pour le plugin.
     52                $fichier_cache = cache_cache_nommer($plugin, $cache, $configuration[$plugin])) {
     53        } elseif (is_string($cache)) {
     54                // Le chemin complet du fichier cache est fourni. Aucune vérification ne peut être faite
     55                // il faut donc que l'appelant ait utilisé l'API cache_existe() pour calculer le fichier au préalable.
     56                $fichier_cache = $cache;
     57        }
     58       
     59        if ($fichier_cache) {
    4960                // Suivant que la configuration demande un sérialisation ou pas, on vérife le format du contenu
    5061                // de façon à toujours écrire une chaine.
    5162                $contenu_cache = '';
    52                 if ($configuration['serialisation']) {
     63                if ($configuration[$plugin]['serialisation']) {
    5364                        if (!is_array($contenu)) {
    5465                                $contenu_cache = $contenu_cache ? array($contenu_cache) : array();
     
    6475                include_spip('inc/flock');
    6576                $ecrire = 'ecrire_fichier';
    66                 if ($configuration['securisation']) {
     77                if ($configuration[$plugin]['securisation']) {
    6778                        $ecrire = 'ecrire_fichier_securise';
    6879                }
     
    7182       
    7283        return $cache_ecrit;
     84}
     85
     86
     87/**
     88 * Lit le cache spécifié d'un plugin donné et renvoie le contenu sous forme de tableau
     89 * éventuellement vide.
     90 *
     91 * @api
     92 *
     93 * @param string $plugin
     94 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
     95 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     96 * @param array|string $cache
     97 *        Nom et extension du fichier cache.
     98 *
     99 * @return array|string|bool
     100 *        Contenu du fichier sous la forme d'un tableau, d'une chaine ou false si une erreur s'est produite.
     101 */
     102function cache_lire($plugin, $cache) {
     103
     104        // Initialisation du contenu du cache
     105        $cache_lu = false;
     106       
     107        // Lecture de la configuration des caches du plugin.
     108        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel, peu probable pour une lecture).
     109        static $configuration = array();
     110        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
     111                $configuration[$plugin] = cache_cache_configurer($plugin);
     112        }
     113
     114        // Le cache peut-être fourni soit sous la forme d'un chemin complet soit sous la forme d'un
     115        // tableau permettant de calculer le chemin complet. On prend en compte ces deux cas.
     116        $fichier_cache = '';
     117        if (is_array($cache)) {
     118                // Détermination du chemin du cache :
     119                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
     120                //   de la configuration du nom pour le plugin.
     121                $fichier_cache = cache_cache_nommer($plugin, $cache, $configuration[$plugin])) {
     122        } elseif (is_string($cache)) {
     123                // Le chemin complet du fichier cache est fourni. Aucune vérification ne peut être faite
     124                // il faut donc que l'appelant ait utilisé l'API cache_existe() pour calculer le fichier au préalable.
     125                $fichier_cache = $cache;
     126        }
     127
     128        // Détermination du nom du cache en fonction du plugin appelant et du type
     129        if ($fichier_cache) {
     130                // Lecture du fichier cache sécurisé ou pas suivant la configuration.
     131                include_spip('inc/flock');
     132                $lire = 'lire_fichier';
     133                if ($configuration[$plugin]['securisation']) {
     134                        $lire = 'lire_fichier_securise';
     135                }
     136                $contenu_cache = '';
     137                $lecture_ok = $lire($fichier_cache, $contenu_cache);
     138               
     139                if ($lecture_ok) {
     140                        if ($configuration[$plugin]['serialisation']) {
     141                                $cache_lu = unserialize($contenu_cache);
     142                        } else {
     143                                $cache_lu = $contenu_cache;
     144                        }
     145                }
     146        }
     147
     148        return $cache_lu;
     149}
     150
     151
     152/**
     153 * Renvoie le chemin complet du cache si celui-ci existe sinon renvoie une chaine vide.
     154 *
     155 * @api
     156 *
     157 * @param string $plugin
     158 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
     159 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     160 * @param array  $cache
     161 *        Tableau identifiant le cache pour lequel on veut construire le nom.
     162 * @param array  $configuration
     163 *        Configuration complète des caches du plugin utlisateur.
     164 *
     165 * @return string
     166 */
     167function cache_existe($plugin, $cache) {
     168
     169        // Lecture de la configuration des caches du plugin.
     170        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel).
     171        static $configuration = array();
     172        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
     173                $configuration[$plugin] = cache_cache_configurer($plugin);
     174        }
     175
     176        // Le cache peut-être fourni soit sous la forme d'un chemin complet soit sous la forme d'un
     177        // tableau permettant de calculer le chemin complet. On prend en compte ces deux cas.
     178        $fichier_cache = '';
     179        if (is_array($cache)) {
     180                // Détermination du chemin du cache :
     181                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
     182                //   de la configuration du nom pour le plugin.
     183                $fichier_cache = cache_cache_nommer($plugin, $cache, $configuration[$plugin])) {
     184        } elseif (is_string($cache)) {
     185                // Le chemin complet du fichier cache est fourni. Aucune vérification ne peut être faite
     186                // il faut donc que l'appelant ait utilisé l'API cache_existe() pour calculer le fichier au préalable.
     187                $fichier_cache = $cache;
     188        }
     189
     190        // Vérifier l'existence du fichier.
     191        if ($fichier_cache) {
     192                if (!file_exists($fichier_cache)) {
     193                        $fichier_cache = '';
     194                }
     195        }
     196
     197        return $fichier_cache;
     198}
     199
     200
     201/**
     202 * Renvoie le chemin complet du cache si celui-ci existe sinon renvoie une chaine vide.
     203 *
     204 * @api
     205 *
     206 * @param string $plugin
     207 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
     208 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     209 * @param array  $cache
     210 *        Tableau identifiant le cache pour lequel on veut construire le nom.
     211 * @param array  $configuration
     212 *        Configuration complète des caches du plugin utlisateur.
     213 *
     214 * @return string
     215 */
     216function cache_nommer($plugin, $cache) {
     217
     218        // Lecture de la configuration des caches du plugin.
     219        // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel).
     220        static $configuration = array();
     221        if (empty($configuration[$plugin]) and (!$configuration[$plugin] = cache_configuration_lire($plugin))) {
     222                $configuration[$plugin] = cache_cache_configurer($plugin);
     223        }
     224
     225        // Le cache est toujours fourni sous la forme d'un tableau permettant de calculer le chemin complet.
     226        $fichier_cache = '';
     227        if (is_array($cache)) {
     228                // Détermination du chemin du cache :
     229                // - le nom sans extension est construit à partir des éléments fournis sur le conteneur et
     230                //   de la configuration du nom pour le plugin.
     231                $fichier_cache = cache_cache_nommer($plugin, $cache, $configuration[$plugin])) {
     232        }
     233
     234        return $fichier_cache;
     235}
     236
     237
     238/**
     239 * Supprime le ou les caches spécifiés d'un plugin donné.
     240 * A AMELIORER
     241 *
     242 * @api
     243 *
     244 * @param string $plugin
     245 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
     246 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     247 * @param string $nom_cache
     248 *        Nom et extension du fichier cache.
     249 *
     250 * @return void
     251 */
     252function cache_vider($plugin, $caches = array()) {
     253
     254        // Initialisation du retour
     255        $cache_vide = false;
     256
     257        if ($caches) {
     258                $fichiers_cache = is_string($caches) ? array($caches) : $caches;
     259                include_spip('inc/flock');
     260                foreach ($fichiers_cache as $_fichier) {
     261                        supprimer_fichier($_fichier);
     262                }
     263                $cache_vide = true;
     264        }
     265       
     266        return $cache_vide;
    73267}
    74268
     
    100294        return $configuration_lue;
    101295}
    102 
    103 
    104 /**
    105  * Lit le cache spécifié d'un plugin donné et renvoie le contenu sous forme de tableau
    106  * éventuellement vide.
    107  *
    108  * @api
    109  *
    110  * @param string $plugin
    111  *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    112  *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    113  * @param string $nom_cache
    114  *        Nom et extension du fichier cache.
    115  *
    116  * @return array|string|bool
    117  *        Contenu du fichier sous la forme d'un tableau, d'une chaine ou false si une erreur s'est produite.
    118  */
    119 function cache_lire($plugin, $conteneur) {
    120 
    121         // Initialisation du contenu du cache
    122         $cache_lu = false;
    123        
    124         // Lecture de la configuration des caches du plugin.
    125         // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel, peu probable pour une lecture).
    126         static $configuration = array();
    127         if (!$configuration and (!$configuration = cache_configuration_lire($plugin))) {
    128                 $configuration = cache_cache_configurer($plugin);
    129         }
    130 
    131         // Détermination du nom du cache en fonction du plugin appelant et du type
    132         if ($fichier_cache = cache_nommer($plugin, $conteneur, $configuration)) {
    133                 // Lecture du fichier cache sécurisé ou pas suivant la configuration.
    134                 include_spip('inc/flock');
    135                 $lire = 'lire_fichier';
    136                 if ($configuration['securisation']) {
    137                         $lire = 'lire_fichier_securise';
    138                 }
    139                 $contenu_cache = '';
    140                 $lecture_ok = $lire($fichier_cache, $contenu_cache);
    141                
    142                 if ($lecture_ok) {
    143                         if ($configuration['serialisation']) {
    144                                 $cache_lu = unserialize($contenu_cache);
    145                         } else {
    146                                 $cache_lu = $contenu_cache;
    147                         }
    148                 }
    149         }
    150 
    151         return $cache_lu;
    152 }
    153 
    154 
    155 /**
    156  * Renvoie le chemin complet du cache si celui-ci existe sinon renvoie une chaine vide.
    157  *
    158  * @api
    159  *
    160  * @param string $plugin
    161  *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    162  *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    163  * @param array  $conteneur
    164  *        Tableau identifiant le cache pour lequel on veut construire le nom.
    165  * @param array  $configuration
    166  *        Configuration complète des caches du plugin utlisateur.
    167  *
    168  * @return string
    169  */
    170 function cache_existe($plugin, $conteneur) {
    171 
    172         // Lecture de la configuration des caches du plugin.
    173         // Si celle-ci n'existe pas encore elle est créée (cas d'un premier appel, peu probable pour cette fonction).
    174         static $configuration = array();
    175         if (!$configuration and (!$configuration = cache_configuration_lire($plugin))) {
    176                 $configuration = cache_cache_configurer($plugin);
    177         }
    178 
    179         // Détermination du nom du cache en fonction du plugin appelant et du type
    180         if ($fichier_cache = cache_nommer($plugin, $conteneur, $configuration)) {
    181                 // Vérifier l'existence du fichier.
    182                 if (!file_exists($fichier_cache)) {
    183                         $fichier_cache = '';
    184                 }
    185         } else {
    186                 $fichier_cache = '';
    187         }
    188 
    189         return $fichier_cache;
    190 }
    191 
    192 
    193 /**
    194  * Supprime le cache spécifié d'un plugin donné.
    195  *
    196  * @api
    197  *
    198  * @param string $plugin
    199  *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    200  *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    201  * @param string $nom_cache
    202  *        Nom et extension du fichier cache.
    203  *
    204  * @return void
    205  */
    206 function cache_vider($plugin, $caches = array()) {
    207 
    208         // Détermination du nom du cache en fonction du plugin appelant et du type
    209         $fichier_cache = '';
    210 
    211         // Suppression du fichier cache
    212         include_spip('inc/flock');
    213         supprimer_fichier($fichier_cache);
    214 }
Note: See TracChangeset for help on using the changeset viewer.