source: spip-zone/_core_/plugins/svp/inc/svp_decider.php @ 93161

Last change on this file since 93161 was 93161, checked in by marcimat@…, 5 years ago

Lorsqu'on demande la désactivation d'un plugin (bootstrap3) qui procure d'autres plugins (bootstrap), il faut aussi
désactiver les plugins qui dépendent du procure.

  • Property svn:eol-style set to native
File size: 36.0 KB
Line 
1<?php
2
3/**
4 * Gestion du décideur : il calcule en fonction d'une demande d'action
5 * sur les plugins tous les enchainements que cela implique sur les
6 * dépendances.
7 *
8 * @plugin SVP pour SPIP
9 * @license GPL
10 * @package SPIP\SVP\Decideur
11 */
12 
13if (!defined("_ECRIRE_INC_VERSION")) return;
14
15include_spip('plugins/installer'); // pour spip_version_compare()
16include_spip('inc/svp_rechercher'); // svp_verifier_compatibilite_spip()
17# include_spip('inc/plugin'); // plugin_version_compatible() [inclu dans svp_rechercher]
18
19/**
20 * Le décideur calcule les actions qui doivent être faites en fonction
21 * de ce qui est demandé et des différentes dépendances des plugins.
22 *
23 * @package SPIP\SVP\Actionner
24**/
25class Decideur {
26
27        /**
28         * Plugins actifs en cours avant toute modification
29         * @var array
30         *     Index 'i' : plugins triés par identifiant en base [i][32] = tableau de description
31         *     Index 'p' : plugins triés par prefixe de plugin [p][MOTS] = tableau de description
32         */
33        var $start = array(
34                'i' => array(),
35                'p' => array(),
36        );
37
38        /**
39         * Plugins actifs à la fin des modifications effectuées
40         * @var array
41         *     Index 'i' : plugins triés par identifiant en base [i][32] = tableau de description
42         *     Index 'p' : plugins triés par prefixe de plugin [p][MOTS] = tableau de description
43         */
44        var $end = array(
45                'i' => array(),
46                'p' => array(),
47        );
48
49        /**
50         * Plugins procure par SPIP
51         * @var array
52         *     Tableau ('PREFIXE' => numéro de version)
53         */
54        var $procure = array();
55
56        /**
57         * Toutes les actions à faire demandées
58         * (ce que l'on demande à l'origine)
59         * @var array
60         *     Tableau ('identifiant' => tableau de description)
61         */
62        var $ask = array();
63
64        /**
65         * Toutes les actions à faire demandées et consécutives aux dépendances
66         *
67         * @var array
68         *     Tableau ('identifiant' => tableau de description)
69         */
70        var $todo = array();
71
72        /**
73         * Toutes les actions à faire consécutives aux dépendances
74         *
75         * C'est à dire les actions à faire en plus de celles demandées.
76         *
77         * @var array
78         *     Tableau ('identifiant' => tableau de description)
79         */
80        var $changes = array();
81
82        /**
83         * Tous les plugins à arrêter (désactiver ou désinstaller)
84         *
85         * @var array
86         *     Tableau ('PREFIXE' => tableau de description)
87         */
88        var $off = array();
89
90        /**
91         * Tous les plugins invalidés (suite a des dependances introuvables, mauvaise version de SPIP...)
92         *
93         * @var array
94         *     Tableau ('PREFIXE' => tableau de description)
95         */
96        var $invalides = array();
97
98        /**
99         * Liste des erreurs
100         *
101         * @var array
102         *     Tableau ('identifiant' => liste des erreurs)
103         */
104        var $err = array();
105
106        /**
107         * État de santé (absence d'erreur)
108         *
109         * Le résultat true permettra d'effectuer toutes les actions.
110         * Passe à false dès qu'une erreur est présente !
111         *
112         * @var bool */
113        var $ok = true;
114
115        /**
116         * Loguer les différents éléments
117         *
118         * Sa valeur sera initialisée par la configuration 'mode_log_verbeux' de SVP
119         *
120         * @var bool */
121        var $log = false;
122
123        /**
124         * Générer une erreur si on demande une mise à jour d'un plugin
125         * alors qu'on ne la connait pas.
126         * @var bool */
127        var $erreur_sur_maj_introuvable = true;
128
129        /**
130         * Constructeur
131         *
132         * Initialise la propriété $log en fonction de la configuration
133         */
134        function __construct() {
135                include_spip('inc/config');
136                $this->log = (lire_config('svp/mode_log_verbeux') == 'oui');
137        }
138
139
140        /**
141         * Liste des plugins déjà actifs
142         *
143         * @var array
144         *     Index 'i' : plugins triés par identifiant en base [i][32] = tableau de description
145         *     Index 'p' : plugins triés par prefixe de plugin [p][MOTS] = tableau de description
146         */
147        function liste_plugins_actifs() {
148                return $this->infos_courtes(array('pa.actif='.sql_quote('oui'),  'pa.attente=' . sql_quote('non')));
149        }
150
151        /**
152         * Teste si un paquet (via son identifiant) est en attente
153         *
154         * Les plugins en attente ont un statut spécial : à la fois dans la
155         * liste des plugins actifs, mais désactivés. Un plugin passe 'en attente'
156         * lorsqu'il est actif mais perd accidentellement une dépendance,
157         * par exemple si une dépendance est supprimée par FTP.
158         * Dès que sa dépendance revient, le plugin se réactive.
159         *
160         * L'interface de gestion des plugins de SVP, elle, permet pour ces plugins
161         * de les désactiver ou réactiver (retéléchargeant alors la dépendance si possible).
162         *
163         * @param int $id
164         *     Identifiant du plugin
165         * @return bool
166         *     Le plugin est-il en attente ?
167         */
168        function est_attente_id($id) {
169                static $attente = null;
170                if (is_null($attente)) {
171                        $attente = $this->infos_courtes('pa.attente=' . sql_quote('oui'));
172                }
173                return isset($attente['i'][$id]) ? $attente['i'][$id] : false;
174        }
175
176        /**
177         * Liste des plugins procurés par SPIP
178         *
179         * Calcule la liste des plugins que le core de SPIP déclare procurer.
180         *
181         * @return array
182         *     Tableau ('PREFIXE' => version)
183         */
184        function liste_plugins_procure() {
185                $procure = array();
186                $get_infos = charger_fonction('get_infos','plugins');
187                $infos['_DIR_RESTREINT'][''] = $get_infos('./',false,_DIR_RESTREINT);
188
189                foreach($infos['_DIR_RESTREINT']['']['procure'] as $_procure) {
190                        $prefixe = strtoupper($_procure['nom']);
191                        $procure[$prefixe] = $_procure['version'];
192                }
193
194                return $procure;
195        }
196
197        /**
198         * Écrit un log
199         *
200         * Écrit un log si la propriété $log l'autorise.
201         *
202         * @param mixed $quoi
203         *     La chose à logguer (souvent un texte)
204        **/
205        function log($quoi) {
206                if ($this->log) {
207                        spip_log($quoi,'decideur');
208                }
209        }
210
211        /**
212         * Retourne le tableau de description d'un paquet (via son identifiant)
213         *
214         * @note
215         *     Attention, retourne un tableau complexe.
216         *     La description sera dans : ['i'][$id]
217         * @param int $id
218         *     Identifiant du paquet
219         * @return array
220         *     Index 'i' : plugins triés par identifiant en base [i][32] = tableau de description
221         *     Index 'p' : plugins triés par prefixe de plugin [p][MOTS] = tableau de description
222        **/
223        function infos_courtes_id($id) {
224                // on cache ceux la
225                static $plug = array();
226                if (!isset($plug[$id])) {
227                        $plug[$id] = $this->infos_courtes('pa.id_paquet=' . sql_quote($id));
228                }
229                return $plug[$id];
230        }
231
232        /**
233         * Récupérer les infos utiles des paquet
234         *
235         * Crée un tableau de description pour chaque paquet dans une
236         * écriture courte comme index ('i' pour identifiant) tel que :
237         * - i = identifiant
238         * - p = prefixe (en majuscule)
239         * - n = nom du plugin
240         * - v = version
241         * - e = etat
242         * - a = actif
243         * - du = dépendances utilise
244         * - dn = dépendances nécessite
245         * - dl = dépendances librairie
246         * - procure = prefixes procurés
247         * - maj = mise à jour
248         *
249         *
250         * On passe un where ($condition) et on crée deux tableaux, l'un des paquets
251         * triés par identifiant, l'autre par prefixe.
252         *
253         * @param array|string $condition
254         *     Condition where
255         * @param bool $multiple
256         *     Si multiple, le tableau par préfixe est un sous-tableau (il peut alors
257         *     y avoir plusieurs paquets pour un même prefixe, classés par états décroissants)
258         * @return array
259         *     Index 'i' : plugins triés par identifiant en base [i][32] = tableau de description
260         *     Index 'p' : plugins triés par prefixe de plugin [p][MOTS] = tableau de description
261         *                 ou, avec $multiple=true : [p][MOTS][] = tableau de description
262         */
263        function infos_courtes($condition, $multiple = false) {
264                $plugs = array(
265                        'i'=>array(),
266                        'p'=>array()
267                );
268
269                $from = array('spip_paquets AS pa', 'spip_plugins AS pl');
270                $orderby = $multiple ? 'pa.etatnum DESC' : '';
271                $where = array('pa.id_plugin = pl.id_plugin');
272                if (is_array($condition))
273                        $where = array_merge($where, $condition);
274                else
275                        $where[] = $condition;
276
277                include_spip('inc/filtres'); // extraire_multi()
278                $res = sql_allfetsel(array(
279                        'pa.id_paquet AS i',
280                        'pl.nom AS n',
281                        'pl.prefixe AS p',
282                        'pa.version AS v',
283                        'pa.etatnum AS e',
284                        'pa.compatibilite_spip',
285                        'pa.dependances',
286                        'pa.procure',
287                        'pa.id_depot',
288                        'pa.maj_version AS maj',
289                        'pa.actif AS a'), $from, $where, '', $orderby);
290                foreach ($res as $r) {
291                        $r['p'] = strtoupper( $r['p'] ); // on s'assure du prefixe en majuscule.
292                       
293                        // savoir si un paquet est en local ou non...
294                        $r['local'] = ($r['id_depot']) == 0 ? true : false;
295                        unset($r['id_depot']);
296                       
297                        $d = unserialize($r['dependances']);
298                        // voir pour enregistrer en bdd simplement 'n' et 'u' (pas la peine d'encombrer)...
299                        $deps = array('necessite'=>array(array()), 'utilise'=>array(array()), 'librairie'=>array(array()));
300                        if (!$d) $d = $deps;
301                       
302                        unset($r['dependances']);
303                        if (!$r['procure'] OR !$proc = unserialize($r['procure'])){
304                                $proc = array();
305                        }
306                        $r['procure'] = $proc;
307
308                        /*
309                         * On extrait les multi sur le nom du plugin
310                         */
311                        $r['n'] = extraire_multi($r['n']);
312
313                        $plugs['i'][$r['i']] = $r;
314
315                       
316                        // pour chaque type de dependences... (necessite, utilise, librairie)
317                        // on cree un tableau unique [$dependence] = array()
318                        // au lieu de plusieurs tableaux par version de spip
319                        // en ne mettant dans 0 que ce qui concerne notre spip local
320                        foreach($deps as $cle => $defaut) {
321                                if (!isset($d[$cle])) {
322                                        $d[$cle] = $defaut;
323                                }
324                               
325                                // gerer les dependences autres que dans 0 (communs ou local) !!!!
326                                // il peut exister des cles info[dn]["[version_spip_min;version_spip_max]"] de dependences
327                                if (!isset($d[$cle][0]) OR count($d[$cle]) > 1) {
328                                        $dep = array();
329                                        $dep[0] = isset($d[$cle][0]) ? $d[$cle][0] : array();
330                                        unset($d[$cle][0]);
331                                        foreach ($d[$cle] as $version => $dependences) {
332                                                if (svp_verifier_compatibilite_spip($version)) {
333                                                        $dep = array_merge($dep[0], $dependences);
334                                                }
335                                        }
336                                        $d[$cle] = $dep;
337                                }
338                        }
339                        // passer les prefixes en majuscule
340                        foreach($d['necessite'][0] as $i=>$n) {
341                                $d['necessite'][0][$i]['nom'] = strtoupper($n['nom']);
342                        }
343                        $plugs['i'][$r['i']]['dn'] = $d['necessite'][0];
344                        $plugs['i'][$r['i']]['du'] = $d['utilise'][0];
345                        $plugs['i'][$r['i']]['dl'] = $d['librairie'][0];
346
347
348                        if ($multiple) {
349                                $plugs['p'][$r['p']][] = &$plugs['i'][$r['i']]; // alias
350                        } else {
351                                $plugs['p'][$r['p']] = &$plugs['i'][$r['i']]; // alias
352                        }
353
354                }
355                return $plugs;
356        }
357
358
359        /**
360         * Ajoute une erreur sur un paquet
361         *
362         * Passe le flag OK à false : on ne pourra pas faire les actions demandées.
363         *
364         * @param int $id
365         *     Identifiant de paquet
366         * @param string $texte
367         *     Texte de l'erreur
368         */
369        function erreur($id, $texte = '') {
370                $this->log("erreur: $id -> $texte");
371                if (!isset($this->err[$id]) OR !is_array($this->err[$id])) {
372                        $this->err[$id] = array();
373                }
374                $this->err[$id][] = $texte;
375                $this->ok = false;
376        }
377
378        /**
379         * Teste si une erreur est présente sur un paquet (via son identifiant)
380         *
381         * @param int $id
382         *     Identifiant de paquet
383         * @return bool|array
384         *     false si pas d'erreur, tableau des erreurs sinon.
385         */
386        function en_erreur($id) {
387                return isset($this->err[$id]) ? $this->err[$id] : false;
388        }
389
390
391        /**
392         * Vérifie qu'un plugin plus récent existe pour un préfixe et une version donnée
393         *
394         * @param string $prefixe
395         *     Préfixe du plugin
396         * @param string $version
397         *     Compatibilité à comparer, exemple '[1.0;]'
398         * @return bool|array
399         *     false si pas de plugin plus récent trouvé
400         *     tableau de description du paquet le plus récent sinon
401         */
402        function chercher_plugin_recent($prefixe, $version) {
403                $news = $this->infos_courtes(array('pl.prefixe=' . sql_quote($prefixe), 'pa.obsolete=' . sql_quote('non'), 'pa.id_depot > '.sql_quote(0)), true);
404                $res = false;
405                if ($news and count($news['p'][$prefixe]) > 0) {
406                        foreach ($news['p'][$prefixe] as $new) {
407                                if (spip_version_compare($new['v'],$version,'>')) {
408                                        if (!$res or version_compare($new['v'],$res['v'],'>')) {
409                                                $res = $new;
410                                        }
411                                }
412                        }
413                }
414                return $res;
415        }
416
417        /**
418         * Vérifie qu'un plugin existe pour un préfixe et une version donnée
419         *
420         * @param string $prefixe
421         *     Préfixe du plugin
422         * @param string $version
423         *     Compatibilité à comparer, exemple '[1.0;]'
424         * @return bool|array
425         *     false si pas de plugin plus récent trouvé
426         *     tableau de description du paquet le plus récent sinon
427         */
428        function chercher_plugin_compatible($prefixe, $version) {
429                $plugin = array();
430
431                $v = '000.000.000';
432                // on choisit en priorite dans les paquets locaux !
433                $locaux = $this->infos_courtes(array(
434                        'pl.prefixe=' . sql_quote($prefixe),
435                        'pa.obsolete=' . sql_quote('non'),
436                        'pa.id_depot='.sql_quote(0)), true);
437                if ($locaux and isset($locaux['p'][$prefixe]) and count($locaux['p'][$prefixe]) > 0) {
438                        foreach ($locaux['p'][$prefixe] as $new) {
439                                if (plugin_version_compatible($version, $new['v'])
440                                and svp_verifier_compatibilite_spip($new['compatibilite_spip'])
441                                and ($new['v'] > $v)){
442                                        $plugin = $new;
443                                        $v = $new['v'];
444                                }
445                        }
446                }
447
448                // qu'on ait trouve ou non, on verifie si un plugin local ne procure pas le prefixe
449                // dans une version plus recente
450                $locaux_procure = $this->infos_courtes(array(
451                        'pa.procure LIKE ' . sql_quote('%'.$prefixe.'%'),
452                        'pa.obsolete=' . sql_quote('non'),
453                        'pa.id_depot='.sql_quote(0)), true);
454                foreach ($locaux_procure['i'] as $new) {
455                        if (isset($new['procure'][$prefixe])
456                                AND plugin_version_compatible($version, $new['procure'][$prefixe])
457                                AND svp_verifier_compatibilite_spip($new['compatibilite_spip'])
458                                AND spip_version_compare($new['procure'][$prefixe], $v, ">"))
459                        {
460                                $plugin = $new;
461                                $v = $new['v'];
462                        }
463                }
464
465                // sinon dans les paquets distants (mais on ne sait pas encore y trouver les procure)
466                if (!$plugin) {
467                        $distants = $this->infos_courtes(array(
468                                'pl.prefixe=' . sql_quote($prefixe),
469                                'pa.obsolete=' . sql_quote('non'),
470                                'pa.id_depot>'.sql_quote(0)), true);
471                        if ($distants and isset($distants['p'][$prefixe]) and count($distants['p'][$prefixe]) > 0) {
472                                foreach ($distants['p'][$prefixe] as $new) {
473                                        if (plugin_version_compatible($version, $new['v'])
474                                        and svp_verifier_compatibilite_spip($new['compatibilite_spip'])
475                                        and ($new['v'] > $v)){
476                                                $plugin = $new;
477                                                $v = $new['v'];
478                                        }
479                                }
480                        }
481                }
482
483                return ($plugin ? $plugin : false);
484        }
485
486
487        /**
488         * Indique qu'un paquet passe à on (on l'active)
489         *
490         * @param array $info
491         *     Description du paquet
492        **/
493        function add($info) {
494                $this->end['i'][$info['i']] = $info;
495                $this->end['p'][$info['p']] = &$this->end['i'][$info['i']];
496        }
497
498        /**
499         * Indique qu'un paquet passe à off (on le désactive ou désinstalle)
500         *
501         * @param array $info
502         *     Description du paquet
503         * @param bool $recur
504         *     Passer à off les plugins qui en dépendent, de façon récursive ?
505        **/
506        function off($info, $recur = false) {
507                $this->log('- stopper ' . $info['p']);
508                $this->remove($info);
509                $this->off[$info['p']] = $info;
510
511                // si recursif, on stoppe aussi les plugins dependants
512                if ($recur) {
513                        $prefixes = array_merge(array($info['p']), array_keys($info['procure']));
514                        foreach ($this->end['i'] as $id => $plug) {
515                                if (is_array($plug['dn']) and $plug['dn']) {
516                                        foreach ($plug['dn'] as $n) {
517                                                if (in_array($n['nom'], $prefixes)) {
518                                                        $this->change($plug, 'off');
519                                                        $this->off($plug, true);
520                                                }
521                                        }
522                                }
523                        }
524                }
525        }
526
527        /**
528         * Teste qu'un paquet (via son préfixe) sera passé off (désactivé ou désinstallé)
529         *
530         * @param string $prefixe
531         *     Prefixe du paquet
532         * @return bool
533         *     Le paquet sera t'il off ?
534        **/
535        function sera_off($prefixe) {
536                return isset($this->off[$prefixe]) ? $this->off[$prefixe] : false;
537        }
538
539        /**
540         * Teste qu'un paquet (via son identifiant) sera passé off (désactivé ou désinstallé)
541         *
542         * @param int $id
543         *     Identifiant du paquet
544         * @return bool
545         *     Le paquet sera t'il off ?
546        **/
547        function sera_off_id($id) {
548                foreach ($this->off as $info) {
549                        if ($info['i'] == $id) {
550                                return $info;
551                        }
552                }
553                return false;
554        }
555
556        /**
557         * Teste qu'un paquet (via son préfixe) sera actif directement
558         * ou par l'intermediaire d'un procure
559         *
560         * @param string $prefixe
561         *     Préfixe du paquet
562         * @return bool
563         *     Le paquet sera t'il actif ?
564        **/
565        function sera_actif($prefixe) {
566                if (isset($this->end['p'][$prefixe])) return $this->end['p'][$prefixe];
567                // sinon regarder les procure
568                $v = "0.0.0";
569                $plugin = false;
570                foreach($this->end['p'] as $prefixe=>$end){
571                        if (isset($end['procure'])
572                                AND $end['procure']
573                          AND isset($end['procure'][$prefixe])
574                          AND spip_version_compare($end['procure'][$prefixe],$v,">")){
575                                $v = $end['procure'][$prefixe];
576                                $plugin = $this->end['p'][$prefixe];
577                        }
578                }
579                return $plugin;
580        }
581
582        /**
583         * Teste qu'un paquet (via son identifiant) sera actif
584         *
585         * @param int $id
586         *     Identifiant du paquet
587         * @return bool
588         *     Le paquet sera t'il actif ?
589        **/
590        function sera_actif_id($id) {
591                return isset($this->end['i'][$id]) ? $this->end['i'][$id] : false;
592        }
593
594        /**
595         * Ajouter une action/paquet à la liste des demandées
596         *
597         * L'ajoute aussi à la liste de toutes les actions !
598         *
599         * @param array $info
600         *     Description du paquet concerné
601         * @param string $quoi
602         *     Type d'action (on, off, kill, upon...)
603         */
604        function ask($info, $quoi) {
605                $this->ask[$info['i']] = $info;
606                $this->ask[$info['i']]['todo'] = $quoi;
607                $this->todo($info, $quoi);
608        }
609
610        /**
611         * Ajouter une action/paquet à la liste des changements en plus
612         * par rapport à la demande initiale
613         *
614         * L'ajoute aussi à la liste de toutes les actions !
615         *
616         * @param array $info
617         *     Description du paquet concerné
618         * @param string $quoi
619         *     Type d'action (on, off, kill, upon...)
620         */
621        function change($info, $quoi) {
622                $this->changes[$info['i']] = $info;
623                $this->changes[$info['i']]['todo'] = $quoi;
624                $this->todo($info, $quoi);
625        }
626
627
628        /**
629         * Annule une action (automatique) qui finalement était réellement demandée.
630         *
631         * Par exemple, une mise à 'off' de paquet entraîne d'autres mises à
632         * 'off' des paquets qui en dépendent. Si une action sur un des paquets
633         * dépendants était aussi demandée, il faut annuler l'action automatique.
634         *
635         * @param array $info
636         *     Description du paquet concerné
637         */
638        function annule_change($info) {
639                unset($this->changes[$info['i']]);
640        }
641
642        /**
643         * Ajouter une action/paquet à la liste de toutes les actions à faire
644         *
645         * @param array $info
646         *     Description du paquet concerné
647         * @param string $quoi
648         *     Type d'action (on, off, kill, upon...)
649         */
650        function todo($info, $quoi) {
651                $this->todo[$info['i']] = $info;
652                $this->todo[$info['i']]['todo'] = $quoi;
653        }
654
655        /**
656         * Retire un paquet de la liste des paquets à activer
657         *
658         * @param array $info
659         *     Description du paquet concerné
660         */
661        function remove($info) {
662                // aucazou ce ne soit pas les memes ids entre la demande et la bdd,
663                // on efface aussi avec l'id donne par le prefixe.
664                // Lorsqu'on desactive un plugin en "attente", il n'est pas actif !
665                // on teste tout de meme donc qu'il est la ce prefixe !
666                $i = false;
667                if (isset($this->end['p'][$info['p']])) {
668                        $i = $this->end['p'][$info['p']];
669                }
670                // on enleve les cles par id indique et par prefixe
671                unset($this->end['i'][$info['i']], $this->end['p'][$info['p']]);
672                // ainsi que l'id aucazou du prefixe
673                if ($i) {
674                        unset($this->end['i'][$i['i']]);
675                }
676
677        }
678
679
680        /**
681         * Invalide un plugin (il est introuvable, ne correspond pas à notre version de SPIP...)
682         *
683         * @param array $info
684         *     Description du paquet concerné
685         */
686        function invalider($info) {
687                $this->log("-> invalider $info[p]");
688                $this->remove($info); // suffisant ?
689                $this->invalides[$info['p']] = $info;
690                $this->annule_change($info);
691                unset($this->todo[$info['i']]);
692        }
693
694        /**
695         * Teste qu'un paquet (via son préfixe) est déclaré invalide
696         *
697         * @param string $p
698         *     Prefixe du paquet
699         * @return bool
700         *     Le paquet est t'il invalide ?
701        **/
702        function sera_invalide($p) {
703                return isset($this->invalides[$p]) ? $this->invalides[$p] : false;
704        }
705
706        /**
707         * Teste qu'une librairie (via son nom) est déjà présente
708         *
709         * @param string $lib
710         *     Nom de la librairie
711         * @return bool
712         *     La librairie est-elle présente ?
713        **/
714        function est_presente_lib($lib) {
715                static $libs = false;
716                if ($libs === false) {
717                        include_spip('inc/svp_outiller');
718                        $libs = svp_lister_librairies();
719                }
720                return isset($libs[$lib]) ? $libs[$lib] : false;
721        }
722
723
724        /**
725         * Ajoute les actions demandées au décideur
726         *
727         * Chaque action est analysée et elles sont redispatchées dans différents
728         * tableaux via les méthodes :
729         * - ask  : ce qui est demandé (ils y vont tous)
730         * - todo : ce qui est à faire (ils y vont tous aussi)
731         * - add  : les plugins activés,
732         * - off  : les plugins désactivés
733         *
734         * La fonction peut lever des erreurs sur les actions tel que :
735         * - Paquet demandé inconnu
736         * - Mise à jour introuvable
737         * - Paquet à désactiver mais qui n'est pas actif
738         *
739         * @param array $todo
740         *     Ce qui est demandé de faire
741         *     Tableau identifiant du paquet => type d'action (on, off, up...)
742         * @return bool
743         *     False en cas d'erreur, true sinon
744         */
745        function actionner($todo = null) {
746                if (is_array($todo)) {
747                        foreach ($todo as $id => $t) {
748                                // plusieurs choses nous interessent... Sauf... le simple telechargement
749                                // et la suppression des fichiers (qui ne peuvent etre fait
750                                // que si le plugin n'est pas actif)
751                                $this->log("-- todo: $id/$t");
752
753                                switch ($t) {
754                                        case 'getlib':
755                                                break;
756                                        case 'on':
757                                        case 'geton':
758                                                // ajouter ce plugin dans la liste
759                                                if (!$this->sera_actif_id($id)) {
760                                                        $i = $this->infos_courtes_id($id);
761                                                        if ($i = $i['i'][$id]) {
762                                                                $this->log("--> $t : " . $i['p'] . ' en version : ' . $i['v'] );
763
764                                                                // se mefier : on peut tenter d'activer
765                                                                // un plugin de meme prefixe qu'un autre deja actif
766                                                                // mais qui n'est pas de meme version ou de meme etat
767                                                                // par exemple un plugin obsolete ou un plugin au contraire plus a jour.
768                                                                // dans ce cas, on desactive l'ancien (sans desactiver les dependences)
769                                                                // et on active le nouveau.
770                                                                // Si une dependance ne suit pas, une erreur se produira du coup.
771                                                                if (isset($this->end['p'][ $i['p'] ])) {
772                                                                        $old = $this->end['p'][ $i['p'] ];
773                                                                        $this->log("-->> off : " . $old['p'] . ' en version : ' . $old['v'] );
774                                                                        $this->ask($old, 'off');
775                                                                        $this->todo($old, 'off');
776                                                                        // désactive l'ancien plugin, mais pas les dépendances qui en dépendent
777                                                                        // car normalement, ça devrait suivre...
778                                                                        $this->off($old, false); 
779
780                                                                }
781                                                               
782                                                                // pas de prefixe equivalent actif...
783                                                                $this->add($i);
784                                                                $this->ask($i, $i['local'] ? 'on' : 'geton' );
785                                                               
786                                                        } else {
787                                                                // la c'est vraiment pas normal... Erreur plugin inexistant...
788                                                                // concurrence entre administrateurs ?
789                                                                $this->erreur($id, _T('svp:message_nok_plugin_inexistant',array('plugin' => $id)));
790                                                        }
791                                                }
792                                                break;
793                                        case 'up':
794                                        case 'upon':
795                                                // le plugin peut etre actif !
796                                                // ajouter ce plugin dans la liste et retirer l'ancien
797                                                $i = $this->infos_courtes_id($id);
798                                                if ($i = $i['i'][$id]) {
799                                                        $this->log("--> $t : " . $i['p'] . ' en version : ' . $i['v'] );
800
801                                                        // new : plugin a installer
802                                                        if ($new = $this->chercher_plugin_recent($i['p'], $i['v'])) {
803                                                                $this->log("--> maj : " . $new['p'] . ' en version : ' . $new['v'] );
804                                                                // ajouter seulement si on l'active !
805                                                                // ou si le plugin est actuellement actif
806                                                                if ($t == 'upon' or $this->sera_actif_id($id)) {
807                                                                        $this->remove($i);
808                                                                        $this->add($new);
809                                                                }
810                                                                $this->ask($i, $t);
811                                                        } else {
812                                                                if ($this->erreur_sur_maj_introuvable) {
813                                                                        // on n'a pas trouve la nouveaute !!!
814                                                                        $this->erreur($id, _T('svp:message_nok_maj_introuvable',array('plugin' => $i['n'],'id'=>$id)));
815                                                                }
816                                                        }
817                                                } else {
818                                                        // mauvais identifiant ?
819                                                        // on n'a pas trouve le plugin !!!
820                                                        $this->erreur($id, _T('svp:message_erreur_maj_inconnu',array('id'=>$id)));
821                                                }
822                                                break;
823                                        case 'off':
824                                        case 'stop':
825                                                // retirer ce plugin
826                                                // (il l'est peut etre deja)
827                                                if ($info = $this->sera_actif_id($id)
828                                                or  $info_off = $this->sera_off_id($id)
829                                                // un plugin en attente (desactive parce que sa dependance a disparu certainement par ftp)
830                                                // peut etre desactive
831                                                or $info = $this->est_attente_id($id)) {
832                                                        // annuler le signalement en "proposition" (due a une mise a 'off' recursive)
833                                                        // de cet arret de plugin, vu qu'on le demande reellement
834                                                        if (!$info) {
835                                                                $info = $info_off;
836                                                                $this->annule_change($info);
837                                                        }
838                                                        $this->log("--> $t : " . $info['p'] . ' en version : ' . denormaliser_version($info['v']) );
839                                                        $this->ask($info, $t);
840                                                        $this->todo($info, $t);
841                                                        // désactive tous les plugins qui en dépendent aussi.
842                                                        $this->off($info, true);
843
844                                                } else {
845                                                        // pas normal... plugin deja inactif...
846                                                        // concurrence entre administrateurs ?
847                                                        $this->erreur($id, _T('svp:message_erreur_plugin_non_actif'));
848                                                }
849                                                break;
850                                        case 'null':
851                                        case 'get':
852                                        case 'kill':
853                                                if ($info = $this->infos_courtes_id($id)) {
854                                                        $this->log("--> $t : " . $info['i'][$id]['p'] . ' en version : ' . $info['i'][$id]['v'] );
855                                                        $this->ask($info['i'][$id], $t);
856                                                } else {
857                                                        // pas normal... plugin inconnu... concurrence entre administrateurs ?
858                                                        $this->erreur($id, _T('svp:message_erreur_plugin_introuvable',array('plugin'=>$id,'action'=>$t)));
859                                                }
860                                                break;
861                                }
862                        }
863                }
864                return $this->ok;
865        }
866
867
868        /**
869         * Initialise les listes de plugins pour le calcul de dépendances
870         *
871         * Les propriété $start et $end reçoivent la liste des plugins actifs
872         * $procure celle des plugins procurés par le Core
873         */
874        function start() {
875                $this->start = $this->end = $this->liste_plugins_actifs();
876                $this->procure = $this->liste_plugins_procure();
877        }
878
879        /**
880         * Vérifier (et activer) les dépendances
881         *
882         * Pour chaque plugin qui sera actif, vérifie qu'il respecte
883         * ses dépendances.
884         *
885         * Si ce n'est pas le cas, le plugin n'est pas activé et le calcul
886         * de dépendances se refait sans lui. À un moment on a normalement
887         * rapidement une liste de plugins cohérents (au pire on ne boucle
888         * que 100 fois maximum - ce qui ne devrait jamais se produire).
889         *
890         * Des erreurs sont levées lorsqu'un plugin ne peut honorer son activation
891         * à cause d'un problème de dépendance. On peut les récupérer dans la
892         * propriété $err.
893         *
894         * @api
895         * @param array $todo
896         *     Ce qui est demandé de faire
897         *     Tableau identifiant du paquet => type d'action (on, off, up...)
898         * @return bool
899         *     False en cas d'erreur, true sinon
900         */
901        function verifier_dependances($todo = null) {
902
903                $this->start();
904
905                // ajouter les actions
906                if (!$this->actionner($todo)) {
907                        $this->log("! Todo en echec !");
908                        $this->log($this->err);
909                        return false;
910                }
911
912                // doit on reverifier les dependances ?
913                // oui des qu'on modifie quelque chose...
914                // attention a ne pas boucler infiniment !
915
916                $supersticieux = 0;
917                do {
918                        $try_again = 0;
919                        $supersticieux++;
920
921                        // verifier chaque dependance de chaque plugin a activer
922                        foreach ($this->end['i'] as $info) {
923                                if (!$this->verifier_dependances_plugin($info)) {
924                                        $try_again = true;
925                                }
926                        }
927                        unset($id, $info);
928                        $this->log("--------> try_again: $try_again, supersticieux: $supersticieux");
929                } while ($try_again > 0 and $supersticieux < 100); # and !count($this->err)
930
931                $this->log("Fin !");
932                $this->log("Ok: " . $this->ok);
933                # $this->log($this->todo);
934
935                return $this->ok;
936        }
937
938
939        /**
940         * Pour une description de paquet donnée, vérifie sa validité.
941         *
942         * Teste la version de SPIP, les librairies nécessitées, ses dépendances
943         * (et tente de les trouver et ajouter si elles ne sont pas là)
944         *
945         * Lorsqu'une dépendance est activée, on entre en récursion
946         * dans cette fonction avec la description de la dépendance
947         *
948         * @param array $info
949         *     Description du paquet
950         * @param int $prof
951         *     Profondeur de récursion
952         * @return bool
953         *     false si erreur (dépendance non résolue, incompatibilité...), true sinon
954        **/
955        function verifier_dependances_plugin($info, $prof = 0) {
956                $this->log("- [$prof] verifier dependances " . $info['p']);
957                $id = $info['i'];
958                $err = false; // variable receptionnant parfois des erreurs
959                $cache = array(); // cache des actions realisees dans ce tour
960
961                // 1
962                // tester la version de SPIP de notre paquet
963                // si on ne valide pas, on retourne une erreur !
964                // mais normalement, on ne devrait vraiment pas pouvoir tomber sur ce cas
965                if (!svp_verifier_compatibilite_spip($info['compatibilite_spip'])) {
966                        $this->invalider($info);
967                        $this->erreur($id, _T('svp:message_incompatibilite_spip',array('plugin'=>$info['n'])));
968                        return false;
969                }
970
971
972                // 2
973                // ajouter les librairies necessaires a notre paquet
974                if (is_array($info['dl']) and count($info['dl'])) {
975                        foreach ($info['dl'] as $l) {
976                                // $l = array('nom' => 'x', 'lien' => 'url')
977                                $lib = $l['nom'];
978                                $this->log("## Necessite la librairie : " . $lib );
979
980                                // on verifie sa presence OU le fait qu'on pourra la telecharger
981                                if ($lib and !$this->est_presente_lib($lib)) {
982                                        // peut on ecrire ?
983                                        if (!is_writable(_DIR_LIB)) {
984                                                $this->invalider($info);
985                                                $this->erreur($id, _T('svp:message_erreur_ecriture_lib', array('plugin'=>$info['n'], 'lib_url'=>$l['lien'], 'lib'=>$lib)));
986                                                $err = true;
987                                        }
988                                        // ajout, pour info
989                                        // de la librairie dans la todo list
990                                        else {
991                                                $this->change(array(
992                                                        'i' => md5(serialize($l)),
993                                                        'p' => $lib,
994                                                        'n' => $lib,
995                                                        'v' => $l['lien'],
996                                                ), 'getlib');
997                                                $this->log("- La librairie $lib sera a télécharger");
998                                        }
999                                }
1000                        }
1001                        if ($err) {
1002                                return false;
1003                        }
1004                }
1005
1006                // 3
1007                // Trouver les dependences aux necessites
1008                // et les activer au besoin
1009                if (is_array($info['dn']) and count($info['dn'])) {
1010                        foreach ($info['dn'] as $n) {
1011
1012                                $p = $n['nom'];
1013                                $v = $n['compatibilite'];
1014
1015                                if ($p == 'SPIP') {
1016                                        // c'est pas la que ça se fait !
1017                                        // ca ne devrait plus apparaitre comme dependence a un plugin.
1018                                }
1019
1020                                // le core procure le paquet que l'on demande !
1021                                elseif ((array_key_exists($p, $this->procure))
1022                                  and (plugin_version_compatible($v, $this->procure[$p], 'spip'))) {
1023                                        // rien a faire...
1024                                        $this->log("-- est procure par le core ($p)");
1025
1026                                }
1027
1028                                // pas d'autre alternative qu'un vrai paquet a activer
1029                                else {
1030                                        $this->log("-- verifier : $p");
1031                                        // nous sommes face a une dependance de plugin
1032                                        // on regarde s'il est present et a la bonne version
1033                                        // sinon on le cherche et on l'ajoute
1034                                        if ($ninfo = $this->sera_actif($p)
1035                                        and !$err = $this->en_erreur($ninfo['i'])
1036                                        and plugin_version_compatible($v, $ninfo['v'])) {
1037                                                // il est deja actif ou a activer, et tout est ok
1038                                                $this->log('-- dep OK pour '.$info['p'].' : '.$p);
1039                                        }
1040                                        // il faut le trouver et demander a l'activer
1041                                        else {
1042                                       
1043                                                // absent ou erreur ou pas compatible
1044                                                $etat = $err ? 'erreur' : ($ninfo ? 'conflit' : 'absent');
1045                                                // conflit signifie qu'il existe le prefixe actif, mais pas a la version demandee
1046                                                $this->log("Dependance " . $p . " a resoudre ! ($etat)");
1047
1048                                                switch ($etat) {
1049                                                        // commencons par le plus simple :
1050                                                        // en cas d'absence, on cherche ou est ce plugin !
1051                                                        case 'absent':
1052                                                                // on choisit par defaut le meilleur etat de plugin.
1053                                                                // de preference dans les plugins locaux, sinon en distant.
1054                                                                if (!$this->sera_off($p)
1055                                                                and $new = $this->chercher_plugin_compatible($p, $v)
1056                                                                and $this->verifier_dependances_plugin($new, ++$prof)) {
1057                                                                        // si le plugin existe localement et possede maj_version,
1058                                                                        // c'est que c'est peut etre une mise a jour + activation a faire
1059                                                                        // si le plugin
1060                                                                        // nouveau est local   => non
1061                                                                        // nouveau est distant => oui peut etre
1062                                                                        $cache[] = $new;
1063                                                                        $i = array();
1064                                                                        if (!$new['local']) {
1065                                                                                $i = $this->infos_courtes(array(
1066                                                                                                'pl.prefixe=' . sql_quote($new['p']),
1067                                                                                                'pa.maj_version=' . sql_quote($new['v'])
1068                                                                                        ), true);
1069                                                                        }
1070                                                                        if ($i and isset($i['p'][$new['p']]) and count($i['p'][$new['p']])) {
1071                                                                                // c'est une mise a jour
1072                                                                                $vieux = $i['p'][$new['p']][0];
1073                                                                                $this->change($vieux, 'upon');
1074                                                                                $this->log("-- update+active : $p");
1075                                                                        } else {
1076                                                                                // tout nouveau tout beau
1077                                                                                $this->change($new, $new['local'] ? 'on' : 'geton');
1078                                                                                if ($new['local']) {
1079                                                                                        $this->log("-- nouveau present : $p");
1080                                                                                } else {
1081                                                                                        $this->log("-- nouveau distant : $p");
1082                                                                                }
1083                                                                        }
1084                                                                        $this->add($new);
1085                                                                } else {
1086                                                                        $this->log("-- !erreur : $p");
1087                                                                        // on ne trouve pas la dependance !
1088                                                                        $this->invalider($info);
1089                                                                        $this->erreur($id, $v ? _T('svp:message_dependance_plugin_version', array('plugin'=>$info['n'], 'dependance'=>$p, 'version'=>$v)) : _T('svp:message_dependance_plugin',array('plugin'=>$info['n'],'dependance'=>$p)));
1090                                                                }
1091                                                                unset($new, $vieux);
1092                                                                break;
1093
1094                                                        case 'erreur':
1095                                                                break;
1096
1097                                                        // present, mais conflit de version
1098                                                        // de deux choses l'une :
1099                                                        // soit on trouve un paquet meilleur...
1100                                                        // soit pas :)
1101                                                        case 'conflit':
1102                                                                $this->log("  conflit -> demande $v, present : " . $ninfo['v']);
1103                                                                if (!$this->sera_off($p)
1104                                                                and $new = $this->chercher_plugin_compatible($p, $v)
1105                                                                and $this->verifier_dependances_plugin($new, ++$prof)) {
1106                                                                        // on connait le nouveau...
1107                                                                        $cache[] = $new;
1108                                                                        $this->remove($ninfo);
1109                                                                        $this->add($new);
1110                                                                        $this->change($ninfo,'up');
1111                                                                        $this->log("-- update : $p");
1112                                                                } else {
1113                                                                        $this->log("-- !erreur : $p");
1114                                                                        // on ne trouve pas la dependance !
1115                                                                        $this->invalider($info);
1116                                                                        $this->erreur($id, $v ? _T('svp:message_dependance_plugin_version', array('plugin'=>$info['n'], 'dependance'=>$p, 'version'=>$v)) : _T('svp:message_dependance_plugin',array('plugin'=>$info['n'],'dependance'=>$p)));
1117                                                                }
1118                                                                break;
1119                                                }
1120
1121                                        } 
1122                                }
1123
1124                                if ($this->sera_invalide($info['p'])) {
1125                                        break;
1126                                }
1127                        }
1128                        unset($n, $v, $p, $ninfo, $present, $conflit, $erreur, $err);
1129
1130                        // si le plugin est devenu invalide...
1131                        // on invalide toutes les actions qu'on vient de faire !
1132                        if ($this->sera_invalide($info['p'])) {
1133                                $this->log("> Purge du cache");
1134                                foreach ($cache as $i) {
1135                                        $this->invalider($i);
1136                                }
1137                                return false;
1138                        }
1139                }
1140                return true;
1141        }
1142
1143        /**
1144         * Retourne un tableau des différentes actions qui seront faites
1145         *
1146         * @param string $quoi
1147         *     Type de demande
1148         *     - ask : les actions demandées
1149         *     - changes : les actions en plus par rapport à ce qui était demandé
1150         *     - todo : toutes les actions
1151         * @return array
1152         *     Liste des actions (joliement traduites et expliquées)
1153        **/
1154        function presenter_actions($quoi) {
1155                $res = array();
1156                foreach ($this->$quoi as $id=>$info) {
1157                        $trads = array(
1158                                'plugin'  => $info['n'],
1159                                'version' => denormaliser_version($info['v']),
1160                        );
1161                        if (isset($info['maj'])) {
1162                                $trads['version_maj'] = denormaliser_version($info['maj']);
1163                        }
1164                        $res[] = _T('svp:message_action_'.$info['todo'], $trads);
1165                }
1166                return $res;
1167        }
1168}
1169
1170
1171/**
1172 * Gère la partie vérifier des formulaires utilisant le Décideur
1173 *
1174 * @param array $a_actionner
1175 *     Tableau des actions par paquet (id_paquet => action)
1176 * @param array $erreurs
1177 *     Tableau d'erreurs de verifier (CVT)
1178 * @return bool
1179 *     true si tout va bien, false sinon (erreur pour trouver les dépendances, ...)
1180**/
1181function svp_decider_verifier_actions_demandees($a_actionner, &$erreurs) {
1182        $decideur = new Decideur;
1183        $decideur->erreur_sur_maj_introuvable = false;
1184        $decideur->verifier_dependances($a_actionner);
1185
1186        if (!$decideur->ok) {
1187                $erreurs['decideur_erreurs'] = array();
1188                foreach ($decideur->err as $id=>$errs) {
1189                        foreach($errs as $err) {
1190                                $erreurs['decideur_erreurs'][] = $err;
1191                        }
1192                }
1193                return false;
1194        }
1195
1196        // On construit la liste des libellés d'actions
1197        $actions = array();
1198        $actions['decideur_propositions'] = $decideur->presenter_actions('changes');
1199        $actions['decideur_demandes']     = $decideur->presenter_actions('ask');
1200        $actions['decideur_actions']      = $decideur->presenter_actions('todo');
1201        set_request('_libelles_actions', $actions);
1202
1203        // On construit la liste des actions pour la passer au formulaire en hidden
1204        $todo = array();
1205        foreach ($decideur->todo as $_todo) {
1206                $todo[$_todo['i']] = $_todo['todo'];
1207        }
1208        set_request('_todo', serialize($todo));
1209        return true;
1210}
1211?>
Note: See TracBrowser for help on using the repository browser.