dépôts / ptitvelo / web / www.git / blob
? search:


b2326ecc22f0d8a0ee4ace24737717bd00b29968
[ptitvelo/web/www.git] / www / plugins-dist / svp / inc / svp_decider.php
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
13 if (!defined("_ECRIRE_INC_VERSION")) return;
14
15 include_spip('plugins/installer'); // pour spip_version_compare()
16 include_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 **/
25 class 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 Decideur () {
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 * - maj = mise à jour
247 *
248 *
249 * On passe un where ($condition) et on crée deux tableaux, l'un des paquets
250 * triés par identifiant, l'autre par prefixe.
251 *
252 * @param array|string $condition
253 * Condition where
254 * @param bool $multiple
255 * Si multiple, le tableau par préfixe est un sous-tableau (il peut alors
256 * y avoir plusieurs paquets pour un même prefixe, classés par états décroissants)
257 * @return array
258 * Index 'i' : plugins triés par identifiant en base [i][32] = tableau de description
259 * Index 'p' : plugins triés par prefixe de plugin [p][MOTS] = tableau de description
260 * ou, avec $multiple=true : [p][MOTS][] = tableau de description
261 */
262 function infos_courtes($condition, $multiple=false) {
263 $plugs = array(
264 'i'=>array(),
265 'p'=>array()
266 );
267
268 $from = array('spip_paquets AS pa', 'spip_plugins AS pl');
269 $orderby = $multiple ? 'pa.etatnum DESC' : '';
270 $where = array('pa.id_plugin = pl.id_plugin');
271 if (is_array($condition))
272 $where = array_merge($where, $condition);
273 else
274 $where[] = $condition;
275
276 include_spip('inc/filtres'); // extraire_multi()
277 $res = sql_allfetsel(array(
278 'pa.id_paquet AS i',
279 'pl.nom AS n',
280 'pl.prefixe AS p',
281 'pa.version AS v',
282 'pa.etatnum AS e',
283 'pa.compatibilite_spip',
284 'pa.dependances',
285 'pa.id_depot',
286 'pa.maj_version AS maj',
287 'pa.actif AS a'), $from, $where, '', $orderby);
288 foreach ($res as $r) {
289 $r['p'] = strtoupper( $r['p'] ); // on s'assure du prefixe en majuscule.
290
291 // savoir si un paquet est en local ou non...
292 $r['local'] = ($r['id_depot']) == 0 ? true : false;
293 unset($r['id_depot']);
294
295 $d = unserialize($r['dependances']);
296 // voir pour enregistrer en bdd simplement 'n' et 'u' (pas la peine d'encombrer)...
297 $deps = array('necessite'=>array(array()), 'utilise'=>array(array()), 'librairie'=>array(array()));
298 if (!$d) $d = $deps;
299
300 unset($r['dependances']);
301
302 /*
303 * On extrait les multi sur le nom du plugin
304 */
305 $r['n'] = extraire_multi($r['n']);
306
307 $plugs['i'][$r['i']] = $r;
308
309
310 // pour chaque type de dependences... (necessite, utilise, librairie)
311 // on cree un tableau unique [$dependence] = array()
312 // au lieu de plusieurs tableaux par version de spip
313 // en ne mettant dans 0 que ce qui concerne notre spip local
314 foreach($deps as $cle => $defaut) {
315 if (!isset($d[$cle])) {
316 $d[$cle] = $defaut;
317 }
318
319 // gerer les dependences autres que dans 0 (communs ou local) !!!!
320 // il peut exister des cles info[dn]["[version_spip_min;version_spip_max]"] de dependences
321 if (!isset($d[$cle][0]) OR count($d[$cle]) > 1) {
322 $dep = array();
323 $dep[0] = isset($d[$cle][0]) ? $d[$cle][0] : array();
324 unset($d[$cle][0]);
325 foreach ($d[$cle] as $version => $dependences) {
326 if (svp_verifier_compatibilite_spip($version)) {
327 $dep = array_merge($dep[0], $dependences);
328 }
329 }
330 $d[$cle] = $dep;
331 }
332 }
333 // passer les prefixes en majuscule
334 foreach($d['necessite'][0] as $i=>$n) {
335 $d['necessite'][0][$i]['nom'] = strtoupper($n['nom']);
336 }
337 $plugs['i'][$r['i']]['dn'] = $d['necessite'][0];
338 $plugs['i'][$r['i']]['du'] = $d['utilise'][0];
339 $plugs['i'][$r['i']]['dl'] = $d['librairie'][0];
340
341
342 if ($multiple) {
343 $plugs['p'][$r['p']][] = &$plugs['i'][$r['i']]; // alias
344 } else {
345 $plugs['p'][$r['p']] = &$plugs['i'][$r['i']]; // alias
346 }
347
348 }
349 return $plugs;
350 }
351
352
353 /**
354 * Ajoute une erreur sur un paquet
355 *
356 * Passe le flag OK à false : on ne pourra pas faire les actions demandées.
357 *
358 * @param int $id
359 * Identifiant de paquet
360 * @param string $texte
361 * Texte de l'erreur
362 */
363 function erreur($id, $texte = '') {
364 $this->log("erreur: $id -> $texte");
365 if (!isset($this->err[$id]) OR !is_array($this->err[$id])) {
366 $this->err[$id] = array();
367 }
368 $this->err[$id][] = $texte;
369 $this->ok = false;
370 }
371
372 /**
373 * Teste si une erreur est présente sur un paquet (via son identifiant)
374 *
375 * @param int $id
376 * Identifiant de paquet
377 * @return bool|array
378 * false si pas d'erreur, tableau des erreurs sinon.
379 */
380 function en_erreur($id) {
381 return isset($this->err[$id]) ? $this->err[$id] : false;
382 }
383
384
385 /**
386 * Vérifie qu'un plugin plus récent existe pour un préfixe et une version donnée
387 *
388 * @param string $prefixe
389 * Préfixe du plugin
390 * @param string $version
391 * Compatibilité à comparer, exemple '[1.0;]'
392 * @return bool|array
393 * false si pas de plugin plus récent trouvé
394 * tableau de description du paquet le plus récent sinon
395 */
396 function chercher_plugin_recent($prefixe, $version) {
397 $news = $this->infos_courtes(array('pl.prefixe=' . sql_quote($prefixe), 'pa.obsolete=' . sql_quote('non'), 'pa.id_depot > '.sql_quote(0)), true);
398 $res = false;
399 if ($news and count($news['p'][$prefixe]) > 0) {
400 foreach ($news['p'][$prefixe] as $new) {
401 if (spip_version_compare($new['v'],$version,'>')) {
402 if (!$res or version_compare($new['v'],$res['v'],'>')) {
403 $res = $new;
404 }
405 }
406 }
407 }
408 return $res;
409 }
410
411 /**
412 * Vérifie qu'un plugin existe pour un préfixe et une version donnée
413 *
414 * @param string $prefixe
415 * Préfixe du plugin
416 * @param string $version
417 * Compatibilité à comparer, exemple '[1.0;]'
418 * @return bool|array
419 * false si pas de plugin plus récent trouvé
420 * tableau de description du paquet le plus récent sinon
421 */
422 function chercher_plugin_compatible($prefixe, $version) {
423
424 // on choisit en priorite dans les paquets locaux !
425 $locaux = $this->infos_courtes(array(
426 'pl.prefixe=' . sql_quote($prefixe),
427 'pa.obsolete=' . sql_quote('non'),
428 'pa.id_depot='.sql_quote(0)), true);
429 if ($locaux and isset($locaux['p'][$prefixe]) and count($locaux['p'][$prefixe]) > 0) {
430 foreach ($locaux['p'][$prefixe] as $new) {
431 if (plugin_version_compatible($version, $new['v'])
432 and svp_verifier_compatibilite_spip($new['compatibilite_spip']) ){
433 return $new;
434 }
435 }
436 }
437
438 // sinon dans les paquets distants
439 $distants = $this->infos_courtes(array(
440 'pl.prefixe=' . sql_quote($prefixe),
441 'pa.obsolete=' . sql_quote('non'),
442 'pa.id_depot>'.sql_quote(0)), true);
443 if ($distants and isset($distants['p'][$prefixe]) and count($distants['p'][$prefixe]) > 0) {
444 foreach ($distants['p'][$prefixe] as $new) {
445 if (plugin_version_compatible($version, $new['v'])
446 and svp_verifier_compatibilite_spip($new['compatibilite_spip']) ){
447 return $new;
448 }
449 }
450 }
451
452 return false;
453 }
454
455
456 /**
457 * Indique qu'un paquet passe à on (on l'active)
458 *
459 * @param array $info
460 * Description du paquet
461 **/
462 function add($info) {
463 $this->end['i'][$info['i']] = $info;
464 $this->end['p'][$info['p']] = &$this->end['i'][$info['i']];
465 }
466
467 /**
468 * Indique qu'un paquet passe à off (on le désactive ou désinstalle)
469 *
470 * @param array $info
471 * Description du paquet
472 * @param bool $recur
473 * Passer à off les plugins qui en dépendent, de façon récursive ?
474 **/
475 function off($info, $recur = false) {
476 $this->log('- stopper ' . $info['p']);
477 $this->remove($info);
478 $this->off[$info['p']] = $info;
479
480 // si recursif, on stoppe aussi les plugins dependants
481 if ($recur) {
482 foreach ($this->end['i'] as $id => $plug) {
483 if (is_array($plug['dn']) and $plug['dn']) {
484 foreach ($plug['dn'] as $n) {
485 if ($info['p'] == $n['nom']) {
486 $this->change($plug, 'off');
487 $this->off($plug, true);
488 }
489 }
490 }
491 }
492 }
493 }
494
495 /**
496 * Teste qu'un paquet (via son préfixe) sera passé off (désactivé ou désinstallé)
497 *
498 * @param string $prefixe
499 * Prefixe du paquet
500 * @return bool
501 * Le paquet sera t'il off ?
502 **/
503 function sera_off($prefixe) {
504 return isset($this->off[$prefixe]) ? $this->off[$prefixe] : false;
505 }
506
507 /**
508 * Teste qu'un paquet (via son identifiant) sera passé off (désactivé ou désinstallé)
509 *
510 * @param int $id
511 * Identifiant du paquet
512 * @return bool
513 * Le paquet sera t'il off ?
514 **/
515 function sera_off_id($id) {
516 foreach ($this->off as $info) {
517 if ($info['i'] == $id) {
518 return $info;
519 }
520 }
521 return false;
522 }
523
524 /**
525 * Teste qu'un paquet (via son préfixe) sera actif
526 *
527 * @param string $prefixe
528 * Préfixe du paquet
529 * @return bool
530 * Le paquet sera t'il actif ?
531 **/
532 function sera_actif($prefixe) {
533 return isset($this->end['p'][$prefixe]) ? $this->end['p'][$prefixe] : false;
534 }
535
536 /**
537 * Teste qu'un paquet (via son identifiant) sera actif
538 *
539 * @param int $id
540 * Identifiant du paquet
541 * @return bool
542 * Le paquet sera t'il actif ?
543 **/
544 function sera_actif_id($id) {
545 return isset($this->end['i'][$id]) ? $this->end['i'][$id] : false;
546 }
547
548 /**
549 * Ajouter une action/paquet à la liste des demandées
550 *
551 * L'ajoute aussi à la liste de toutes les actions !
552 *
553 * @param array $info
554 * Description du paquet concerné
555 * @param string $quoi
556 * Type d'action (on, off, kill, upon...)
557 */
558 function ask($info, $quoi) {
559 $this->ask[$info['i']] = $info;
560 $this->ask[$info['i']]['todo'] = $quoi;
561 $this->todo($info, $quoi);
562 }
563
564 /**
565 * Ajouter une action/paquet à la liste des changements en plus
566 * par rapport à la demande initiale
567 *
568 * L'ajoute aussi à la liste de toutes les actions !
569 *
570 * @param array $info
571 * Description du paquet concerné
572 * @param string $quoi
573 * Type d'action (on, off, kill, upon...)
574 */
575 function change($info, $quoi) {
576 $this->changes[$info['i']] = $info;
577 $this->changes[$info['i']]['todo'] = $quoi;
578 $this->todo($info, $quoi);
579 }
580
581
582 /**
583 * Annule une action (automatique) qui finalement était réellement demandée.
584 *
585 * Par exemple, une mise à 'off' de paquet entraîne d'autres mises à
586 * 'off' des paquets qui en dépendent. Si une action sur un des paquets
587 * dépendants était aussi demandée, il faut annuler l'action automatique.
588 *
589 * @param array $info
590 * Description du paquet concerné
591 */
592 function annule_change($info) {
593 unset($this->changes[$info['i']]);
594 }
595
596 /**
597 * Ajouter une action/paquet à la liste de toutes les actions à faire
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 todo($info, $quoi) {
605 $this->todo[$info['i']] = $info;
606 $this->todo[$info['i']]['todo'] = $quoi;
607 }
608
609 /**
610 * Retire un paquet de la liste des paquets à activer
611 *
612 * @param array $info
613 * Description du paquet concerné
614 */
615 function remove($info) {
616 // aucazou ce ne soit pas les memes ids entre la demande et la bdd,
617 // on efface aussi avec l'id donne par le prefixe.
618 // Lorsqu'on desactive un plugin en "attente", il n'est pas actif !
619 // on teste tout de meme donc qu'il est la ce prefixe !
620 $i = false;
621 if (isset($this->end['p'][$info['p']])) {
622 $i = $this->end['p'][$info['p']];
623 }
624 // on enleve les cles par id indique et par prefixe
625 unset($this->end['i'][$info['i']], $this->end['p'][$info['p']]);
626 // ainsi que l'id aucazou du prefixe
627 if ($i) {
628 unset($this->end['i'][$i['i']]);
629 }
630
631 }
632
633
634 /**
635 * Invalide un plugin (il est introuvable, ne correspond pas à notre version de SPIP...)
636 *
637 * @param array $info
638 * Description du paquet concerné
639 */
640 function invalider($info) {
641 $this->log("-> invalider $info[p]");
642 $this->remove($info); // suffisant ?
643 $this->invalides[$info['p']] = $info;
644 $this->annule_change($info);
645 unset($this->todo[$info['i']]);
646 }
647
648 /**
649 * Teste qu'un paquet (via son préfixe) est déclaré invalide
650 *
651 * @param string $p
652 * Prefixe du paquet
653 * @return bool
654 * Le paquet est t'il invalide ?
655 **/
656 function sera_invalide($p) {
657 return isset($this->invalides[$p]) ? $this->invalides[$p] : false;
658 }
659
660 /**
661 * Teste qu'une librairie (via son nom) est déjà présente
662 *
663 * @param string $lib
664 * Nom de la librairie
665 * @return bool
666 * La librairie est-elle présente ?
667 **/
668 function est_presente_lib($lib) {
669 static $libs = false;
670 if ($libs === false) {
671 include_spip('inc/svp_outiller');
672 $libs = svp_lister_librairies();
673 }
674 return isset($libs[$lib]) ? $libs[$lib] : false;
675 }
676
677
678 /**
679 * Ajoute les actions demandées au décideur
680 *
681 * Chaque action est analysée et elles sont redispatchées dans différents
682 * tableaux via les méthodes :
683 * - ask : ce qui est demandé (ils y vont tous)
684 * - todo : ce qui est à faire (ils y vont tous aussi)
685 * - add : les plugins activés,
686 * - off : les plugins désactivés
687 *
688 * La fonction peut lever des erreurs sur les actions tel que :
689 * - Paquet demandé inconnu
690 * - Mise à jour introuvable
691 * - Paquet à désactiver mais qui n'est pas actif
692 *
693 * @param array $todo
694 * Ce qui est demandé de faire
695 * Tableau identifiant du paquet => type d'action (on, off, up...)
696 * @return bool
697 * False en cas d'erreur, true sinon
698 */
699 function actionner($todo = null) {
700 if (is_array($todo)) {
701 foreach ($todo as $id => $t) {
702 // plusieurs choses nous interessent... Sauf... le simple telechargement
703 // et la suppression des fichiers (qui ne peuvent etre fait
704 // que si le plugin n'est pas actif)
705 $this->log("-- todo: $id/$t");
706
707 switch ($t) {
708 case 'getlib':
709 break;
710 case 'on':
711 case 'geton':
712 // ajouter ce plugin dans la liste
713 if (!$this->sera_actif_id($id)) {
714 $i = $this->infos_courtes_id($id);
715 if ($i = $i['i'][$id]) {
716 $this->log("--> $t : " . $i['p'] . ' en version : ' . $i['v'] );
717
718 // se mefier : on peut tenter d'activer
719 // un plugin de meme prefixe qu'un autre deja actif
720 // mais qui n'est pas de meme version ou de meme etat
721 // par exemple un plugin obsolete ou un plugin au contraire plus a jour.
722 // dans ce cas, on desactive l'ancien (sans desactiver les dependences)
723 // et on active le nouveau.
724 // Si une dependance ne suit pas, une erreur se produira du coup.
725 if (isset($this->end['p'][ $i['p'] ])) {
726 $old = $this->end['p'][ $i['p'] ];
727 $this->log("-->> off : " . $old['p'] . ' en version : ' . $old['v'] );
728 $this->ask($old, 'off');
729 $this->todo($old, 'off');
730 // désactive l'ancien plugin, mais pas les dépendances qui en dépendent
731 // car normalement, ça devrait suivre...
732 $this->off($old, false);
733
734 }
735
736 // pas de prefixe equivalent actif...
737 $this->add($i);
738 $this->ask($i, $i['local'] ? 'on' : 'geton' );
739
740 } else {
741 // la c'est vraiment pas normal... Erreur plugin inexistant...
742 // concurrence entre administrateurs ?
743 $this->erreur($id, _T('svp:message_nok_plugin_inexistant',array('plugin' => $id)));
744 }
745 }
746 break;
747 case 'up':
748 case 'upon':
749 // le plugin peut etre actif !
750 // ajouter ce plugin dans la liste et retirer l'ancien
751 $i = $this->infos_courtes_id($id);
752 if ($i = $i['i'][$id]) {
753 $this->log("--> $t : " . $i['p'] . ' en version : ' . $i['v'] );
754
755 // new : plugin a installer
756 if ($new = $this->chercher_plugin_recent($i['p'], $i['v'])) {
757 $this->log("--> maj : " . $new['p'] . ' en version : ' . $new['v'] );
758 // ajouter seulement si on l'active !
759 // ou si le plugin est actuellement actif
760 if ($t == 'upon' or $this->sera_actif_id($id)) {
761 $this->remove($i);
762 $this->add($new);
763 }
764 $this->ask($i, $t);
765 } else {
766 if ($this->erreur_sur_maj_introuvable) {
767 // on n'a pas trouve la nouveaute !!!
768 $this->erreur($id, _T('svp:message_nok_maj_introuvable',array('plugin' => $i['n'],'id'=>$id)));
769 }
770 }
771 } else {
772 // mauvais identifiant ?
773 // on n'a pas trouve le plugin !!!
774 $this->erreur($id, _T('svp:message_erreur_maj_inconnu',array('id'=>$id)));
775 }
776 break;
777 case 'off':
778 case 'stop':
779 // retirer ce plugin
780 // (il l'est peut etre deja)
781 if ($info = $this->sera_actif_id($id)
782 or $info_off = $this->sera_off_id($id)
783 // un plugin en attente (desactive parce sa dependance a disparu certainement par ftp)
784 // peut etre desactive
785 or $info = $this->est_attente_id($id)) {
786 // annuler le signalement en "proposition" (due a une mise a 'off' recursive)
787 // de cet arret de plugin, vu qu'on le demande reellement
788 if (!$info) {
789 $info = $info_off;
790 $this->annule_change($info);
791 }
792 $this->log("--> $t : " . $info['p'] . ' en version : ' . denormaliser_version($info['v']) );
793 $this->ask($info, $t);
794 $this->todo($info, $t);
795 // désactive tous les plugins qui en dépendent aussi.
796 $this->off($info, true);
797
798 } else {
799 // pas normal... plugin deja inactif...
800 // concurrence entre administrateurs ?
801 $this->erreur($id, _T('svp:message_erreur_plugin_non_actif'));
802 }
803 break;
804 case 'null':
805 case 'get':
806 case 'kill':
807 if ($info = $this->infos_courtes_id($id)) {
808 $this->log("--> $t : " . $info['i'][$id]['p'] . ' en version : ' . $info['i'][$id]['v'] );
809 $this->ask($info['i'][$id], $t);
810 } else {
811 // pas normal... plugin inconnu... concurrence entre administrateurs ?
812 $this->erreur($id, _T('svp:message_erreur_plugin_introuvable',array('plugin'=>$id,'action'=>$t)));
813 }
814 break;
815 }
816 }
817 }
818 return $this->ok;
819 }
820
821
822 /**
823 * Initialise les listes de plugins pour le calcul de dépendances
824 *
825 * Les propriété $start et $end reçoivent la liste des plugins actifs
826 * $procure celle des plugins procurés par le Core
827 */
828 function start() {
829 $this->start = $this->end = $this->liste_plugins_actifs();
830 $this->procure = $this->liste_plugins_procure();
831 }
832
833 /**
834 * Vérifier (et activer) les dépendances
835 *
836 * Pour chaque plugin qui sera actif, vérifie qu'il respecte
837 * ses dépendances.
838 *
839 * Si ce n'est pas le cas, le plugin n'est pas activé et le calcul
840 * de dépendances se refait sans lui. À un moment on a normalement
841 * rapidement une liste de plugins cohérents (au pire on ne boucle
842 * que 100 fois maximum - ce qui ne devrait jamais se produire).
843 *
844 * Des erreurs sont levées lorsqu'un plugin ne peut honorer son activation
845 * à cause d'un problème de dépendance. On peut les récupérer dans la
846 * propriété $err.
847 *
848 * @api
849 * @param array $todo
850 * Ce qui est demandé de faire
851 * Tableau identifiant du paquet => type d'action (on, off, up...)
852 * @return bool
853 * False en cas d'erreur, true sinon
854 */
855 function verifier_dependances($todo = null) {
856
857 $this->start();
858
859 // ajouter les actions
860 if (!$this->actionner($todo)) {
861 $this->log("! Todo en echec !");
862 $this->log($decideur->err);
863 return false;
864 }
865
866 // doit on reverifier les dependances ?
867 // oui des qu'on modifie quelque chose...
868 // attention a ne pas boucler infiniment !
869
870 $supersticieux = 0;
871 do {
872 $try_again = 0;
873 $supersticieux++;
874
875 // verifier chaque dependance de chaque plugin a activer
876 foreach ($this->end['i'] as $info) {
877 if (!$this->verifier_dependances_plugin($info)) {
878 $try_again = true;
879 }
880 }
881 unset($id, $info);
882 $this->log("--------> try_again: $try_again, supersticieux: $supersticieux");
883 } while ($try_again > 0 and $supersticieux < 100); # and !count($this->err)
884
885 $this->log("Fin !");
886 $this->log("Ok: " . $this->ok);
887 # $this->log($this->todo);
888
889 return $this->ok;
890 }
891
892
893 /**
894 * Pour une description de paquet donnée, vérifie sa validité.
895 *
896 * Teste la version de SPIP, les librairies nécessitées, ses dépendances
897 * (et tente de les trouver et ajouter si elles ne sont pas là)
898 *
899 * Lorsqu'une dépendance est activée, on entre en récursion
900 * dans cette fonction avec la description de la dépendance
901 *
902 * @param array $info
903 * Description du paquet
904 * @param int $prof
905 * Profondeur de récursion
906 * @return bool
907 * false si erreur (dépendance non résolue, incompatibilité...), true sinon
908 **/
909 function verifier_dependances_plugin($info, $prof=0) {
910 $this->log("- [$prof] verifier dependances " . $info['p']);
911 $id = $info['i'];
912 $err = false; // variable receptionnant parfois des erreurs
913 $cache = array(); // cache des actions realisees dans ce tour
914
915 // 1
916 // tester la version de SPIP de notre paquet
917 // si on ne valide pas, on retourne une erreur !
918 // mais normalement, on ne devrait vraiment pas pouvoir tomber sur ce cas
919 if (!svp_verifier_compatibilite_spip($info['compatibilite_spip'])) {
920 $this->invalider($info);
921 $this->erreur($id, _T('svp:message_incompatibilite_spip',array('plugin'=>$info['n'])));
922 return false;
923 }
924
925
926 // 2
927 // ajouter les librairies necessaires a notre paquet
928 if (is_array($info['dl']) and count($info['dl'])) {
929 foreach ($info['dl'] as $l) {
930 // $l = array('nom' => 'x', 'lien' => 'url')
931 $lib = $l['nom'];
932 $this->log("## Necessite la librairie : " . $lib );
933
934 // on verifie sa presence OU le fait qu'on pourra la telecharger
935 if ($lib and !$this->est_presente_lib($lib)) {
936 // peut on ecrire ?
937 if (!is_writable(_DIR_LIB)) {
938 $this->invalider($info);
939 $this->erreur($id, _T('svp:message_erreur_ecriture_lib', array('plugin'=>$info['n'], 'lib_url'=>$l['lien'], 'lib'=>$lib)));
940 $err = true;
941 }
942 // ajout, pour info
943 // de la librairie dans la todo list
944 else {
945 $this->change(array(
946 'i' => md5(serialize($l)),
947 'p' => $lib,
948 'n' => $lib,
949 'v' => $l['lien'],
950 ), 'getlib');
951 $this->log("- La librairie $lib sera a télécharger");
952 }
953 }
954 }
955 if ($err) {
956 return false;
957 }
958 }
959
960 // 3
961 // Trouver les dependences aux necessites
962 // et les activer au besoin
963 if (is_array($info['dn']) and count($info['dn'])) {
964 foreach ($info['dn'] as $n) {
965
966 $p = $n['nom'];
967 $v = $n['compatibilite'];
968
969 if ($p == 'SPIP') {
970 // c'est pas la que ça se fait !
971 // ca ne devrait plus apparaitre comme dependence a un plugin.
972 }
973
974 // le core procure le paquet que l'on demande !
975 elseif ((array_key_exists($p, $this->procure))
976 and (plugin_version_compatible($v, $this->procure[$p], 'spip'))) {
977 // rien a faire...
978 $this->log("-- est procure par le core ($p)");
979
980 }
981
982 // pas d'autre alternative qu'un vrai paquet a activer
983 else {
984 $this->log("-- verifier : $p");
985 // nous sommes face a une dependance de plugin
986 // on regarde s'il est present et a la bonne version
987 // sinon on le cherche et on l'ajoute
988 if ($ninfo = $this->sera_actif($p)
989 and !$err = $this->en_erreur($ninfo['i'])
990 and plugin_version_compatible($v, $ninfo['v'])) {
991 // il est deja actif ou a activer, et tout est ok
992 $this->log('-- dep OK pour '.$info['p'].' : '.$p);
993 }
994 // il faut le trouver et demander a l'activer
995 else {
996
997 // absent ou erreur ou pas compatible
998 $etat = $err ? 'erreur' : ($ninfo ? 'conflit' : 'absent');
999 // conflit signifie qu'il existe le prefixe actif, mais pas a la version demandee
1000 $this->log("Dedendance " . $p . " a resoudre ! ($etat)");
1001
1002 switch ($etat) {
1003 // commencons par le plus simple :
1004 // en cas d'absence, on cherche ou est ce plugin !
1005 case 'absent':
1006 // on choisit par defaut le meilleur etat de plugin.
1007 // de preference dans les plugins locaux, sinon en distant.
1008 if (!$this->sera_off($p)
1009 and $new = $this->chercher_plugin_compatible($p, $v)
1010 and $this->verifier_dependances_plugin($new, ++$prof)) {
1011 // si le plugin existe localement et possede maj_version,
1012 // c'est que c'est peut etre une mise a jour + activation a faire
1013 // si le plugin
1014 // nouveau est local => non
1015 // nouveau est distant => oui peut etre
1016 $cache[] = $new;
1017 $i = array();
1018 if (!$new['local']) {
1019 $i = $this->infos_courtes(array(
1020 'pl.prefixe=' . sql_quote($new['p']),
1021 'pa.maj_version=' . sql_quote($new['v'])
1022 ), true);
1023 }
1024 if ($i and isset($i['p'][$new['p']]) and count($i['p'][$new['p']])) {
1025 // c'est une mise a jour
1026 $vieux = $i['p'][$new['p']][0];
1027 $this->change($vieux, 'upon');
1028 $this->log("-- update+active : $p");
1029 } else {
1030 // tout nouveau tout beau
1031 $this->change($new, $new['local'] ? 'on' : 'geton');
1032 if ($new['local']) {
1033 $this->log("-- nouveau present : $p");
1034 } else {
1035 $this->log("-- nouveau distant : $p");
1036 }
1037 }
1038 $this->add($new);
1039 } else {
1040 $this->log("-- !erreur : $p");
1041 // on ne trouve pas la dependance !
1042 $this->invalider($info);
1043 $this->erreur($id, $v ? _T('svp:message_dependance_plugin_version',array('plugin'=>$info['n'],'dependance'=>$p,'version'=>denormaliser_version($v))) : _T('svp:message_dependance_plugin',array('plugin'=>$info['n'],'dependance'=>$p)));
1044 }
1045 unset($new, $vieux);
1046 break;
1047
1048 case 'erreur':
1049 break;
1050
1051 // present, mais conflit de version
1052 // de deux choses l'une :
1053 // soit on trouve un paquet meilleur...
1054 // soit pas :)
1055 case 'conflit':
1056 $this->log(" conflit -> demande $v, present : " . $ninfo['v']);
1057 if (!$this->sera_off($p)
1058 and $new = $this->chercher_plugin_compatible($p, $v)
1059 and $this->verifier_dependances_plugin($new, ++$prof)) {
1060 // on connait le nouveau...
1061 $cache[] = $new;
1062 $this->remove($ninfo);
1063 $this->add($new);
1064 $this->change($ninfo,'up');
1065 $this->log("-- update : $p");
1066 } else {
1067 $this->log("-- !erreur : $p");
1068 // on ne trouve pas la dependance !
1069 $this->invalider($info);
1070 $this->erreur($id, $v ? _T('svp:message_dependance_plugin_version',array('plugin'=>$info['n'],'dependance'=>$p,'version'=>denormaliser_version($v))) : _T('svp:message_dependance_plugin',array('plugin'=>$info['n'],'dependance'=>$p)));
1071 }
1072 break;
1073 }
1074
1075 }
1076 }
1077
1078 if ($this->sera_invalide($info['p'])) {
1079 break;
1080 }
1081 }
1082 unset($n, $v, $p, $ninfo, $present, $conflit, $erreur, $err);
1083
1084 // si le plugin est devenu invalide...
1085 // on invalide toutes les actions qu'on vient de faire !
1086 if ($this->sera_invalide($info['p'])) {
1087 $this->log("> Purge du cache");
1088 foreach ($cache as $i) {
1089 $this->invalider($i);
1090 }
1091 return false;
1092 }
1093 }
1094 return true;
1095 }
1096
1097 /**
1098 * Retourne un tableau des différentes actions qui seront faites
1099 *
1100 * @param string $quoi
1101 * Type de demande
1102 * - ask : les actions demandées
1103 * - changes : les actions en plus par rapport à ce qui était demandé
1104 * - todo : toutes les actions
1105 * @return array
1106 * Liste des actions (joliement traduites et expliquées)
1107 **/
1108 function presenter_actions($quoi) {
1109 $res = array();
1110 foreach ($this->$quoi as $id=>$info) {
1111 $res[] = _T('svp:message_action_'.$info['todo'], array(
1112 'plugin'=>$info['n'],
1113 'version'=>denormaliser_version($info['v']),
1114 'version_maj'=>denormaliser_version($info['maj'])));
1115 }
1116 return $res;
1117 }
1118 }
1119
1120
1121 /**
1122 * Gère la partie vérifier des formulaires utilisant le Décideur
1123 *
1124 * @param array $a_actionner
1125 * Tableau des actions par paquet (id_paquet => action)
1126 * @param array $erreurs
1127 * Tableau d'erreurs de verifier (CVT)
1128 * @return bool
1129 * true si tout va bien, false sinon (erreur pour trouver les dépendances, ...)
1130 **/
1131 function svp_decider_verifier_actions_demandees($a_actionner, &$erreurs) {
1132 $decideur = new Decideur;
1133 $decideur->erreur_sur_maj_introuvable = false;
1134 $decideur->verifier_dependances($a_actionner);
1135
1136 if (!$decideur->ok) {
1137 $erreurs['decideur_erreurs'] = array();
1138 foreach ($decideur->err as $id=>$errs) {
1139 foreach($errs as $err) {
1140 $erreurs['decideur_erreurs'][] = $err;
1141 }
1142 }
1143 return false;
1144 }
1145
1146 $erreurs['decideur_propositions'] = $decideur->presenter_actions('changes');
1147 $erreurs['decideur_demandes'] = $decideur->presenter_actions('ask');
1148 $erreurs['decideur_actions'] = $decideur->presenter_actions('todo');
1149
1150 // On construit la liste des actions pour la passer au formulaire en hidden
1151 $todo = array();
1152 foreach ($decideur->todo as $_todo) {
1153 $todo[$_todo['i']] = $_todo['todo'];
1154 }
1155 set_request('_todo', serialize($todo));
1156 return true;
1157 }
1158 ?>
Site oueb du p’Tit véLo dAnS La Tête