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