Changeset 110794 in spip-zone


Ignore:
Timestamp:
Jun 21, 2018, 5:12:07 PM (3 years ago)
Author:
marcimat@…
Message:

On reprend totalement ou presque la commande plugins:activer (on reprend du code de Polatouche).
Je pense que la commande se comporte à peu près pareil qu’avant (à vérifier), avec un tas d’options supplémentaires.

On peut activer des plugins depuis :

  • une liste de préfixes séparés par des espaces (comme avant)
  • un chemin de fichier, contenant une liste de préfixes séparés par des espaces
  • une url d’un site (va utilise Curl et local/config.txt) pour activer les mêmes plugins
  • en demandant à l’utilisateur si rien n’est précisé (comme avant)

La commande détermine automatiquement le choix en fonction des arguments, si l’indication précise
n’est pas transmise

En étant précis


  • spip plugins:activer from-url=https://contrib.spip.net
  • spip plugins:activer from-file=tmp/plugins.txt
  • `spip plugins:activer from-list=saisies,yaml,z-core

En auto-analyse


  • spip plugins:activer https://contrib.spip.net
  • spip plugins:activer tmp/plugins.txt
  • spip plugins:activer saisies yaml z-core

Noter que spip plugins:lister --export exporte par défaut dans tmp/plugins.txt,
et peut donc être réutilisé ici.

Confirmation


À chaque fois une confirmation sera demandée (comme avant).
On peut utiliser "--yes" ou "-y" pour accepter d’office

  • spip plugins:activer saisies -y

La totale


Autre option (comme avant) : activer tous les plugins inactifs

  • spip plugins:activer --all

Mutualisation


Dans le cadre d’un appel de fichier (tmp/plugins.txt) sur un site mutualisé,
le fichier est d’abord cherché dans _DIR_SITE (c’est à dire sites/domaine.tld/tmp/plugins.txt)

Appel collectif :

  • `spipmu "*.domaine.tld" "plugins:activer saisies yaml -y"
  • `spipmu "*.domaine.tld" "plugins:activer tmp/plugins.txt -y"

Note : sans l’option -y, une confirmation sera demandée pour chaque site.

Location:
_outils_/spip-cli/trunk/src/Command
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • _outils_/spip-cli/trunk/src/Command/PluginsActiver.php

    r110765 r110794  
    33namespace Spip\Cli\Command;
    44
     5use Spip\Cli\Loader\Spip;
    56use Symfony\Component\Console\Command\Command;
    67use Symfony\Component\Console\Input\InputArgument;
     
    1213use Symfony\Component\Console\Question\ConfirmationQuestion;
    1314
    14 class PluginsActiver extends Command {
    15     protected function configure() {
    16         $this
    17             ->setName('plugins:activer')
    18             ->setDescription('Active un ou plusieurs plugins.')
    19             ->addArgument(
    20                 'plugins',
    21                 InputArgument::IS_ARRAY,
    22                 'La liste de plugins à activer.'
    23             )
    24             ->addOption(
    25                 'all',
    26                 'a',
    27                 InputOption::VALUE_NONE,
    28                 "Activer tous les plugins disponibles."
    29             )
    30                         ->addOption(
    31                                 'yes',
    32                                 'y',
    33                 InputOption::VALUE_NONE,
    34                                 'Activer les plugins sans poser de question'
    35                         )
    36         ;
    37     }
    38 
    39     protected function execute(InputInterface $input, OutputInterface $output) {
    40         global $spip_loaded;
    41         global $spip_racine;
    42         global $cwd;
    43 
    44         if ($spip_loaded) {
    45             chdir($spip_racine);
    46 
    47             $actifs = unserialize($GLOBALS['meta']['plugin']);
    48 
    49             include_spip('inc/plugin');
    50             $disponibles = liste_plugin_files();
    51             $disponibles = array_map(function ($dir) {
    52                 $get_infos = charger_fonction('get_infos', 'plugins');
    53                 $infos = $get_infos($dir);
    54                 return $infos['prefix'];
    55             }, $disponibles);
    56 
    57             $inactifs = array_filter($disponibles, function ($prefixe) {
    58                 return ! array_key_exists(
    59                     strtoupper($prefixe),
    60                     unserialize($GLOBALS['meta']['plugin'])
    61                 );
    62             });
    63 
    64             /* Si on a choisi l'option --all, on prend tous les
    65                plugins inactifs. */
    66             if ($input->getOption('all')) {
    67                 $plugins = array_map('strtolower', $inactifs);
    68             } else {
    69                 $plugins = $input->getArgument('plugins');
    70             }
    71 
    72                         // Si on est en mode "All" et qu'il n'y a pas de plugin, il n'y a rien a faire
    73                         if (!$plugins and $input->getOption('all')) {
     15class PluginsActiver extends PluginsLister
     16{
     17
     18        protected $todo = [];
     19
     20        protected function configure() {
     21                $this
     22                        ->setName('plugins:activer')
     23                        ->setDescription('Active un ou plusieurs plugins.')
     24                        ->addArgument('from', InputArgument::OPTIONAL | InputArgument::IS_ARRAY, 'Active les plugins listés. Détermine automatiquement l’option from-xxx.')
     25                        ->addOption('from-file', null, InputOption::VALUE_OPTIONAL, 'Chemin d’un fichier d’export')
     26                        ->addOption('from-url', null, InputOption::VALUE_OPTIONAL, 'Url d’un site SPIP')
     27                        ->addOption('from-list', null, InputOption::VALUE_OPTIONAL, 'Liste de préfixes à activer, séparés par virgule')
     28                        ->addOption('all', 'a', InputOption::VALUE_NONE, "Activer tous les plugins disponibles.")
     29                        ->addOption('yes', 'y', InputOption::VALUE_NONE, 'Activer les plugins sans poser de question');
     30        }
     31
     32        protected function execute(InputInterface $input, OutputInterface $output) {
     33                $this->io = $this->getApplication()->getIO($input, $output);
     34
     35                /** @var Spip $spip */
     36                $spip = $this->getApplication()->getService('spip.loader');
     37                $spip->load();
     38                $spip->chdir();
     39
     40                if ($input->getOption('from-file')) {
     41                        $this->addTodo($this->getPrefixesFromFile($input->getOption('from-file')));
     42                } elseif ($input->getOption('from-url')) {
     43                        $this->addTodo($this->getPrefixesFromUrl($input->getOption('from-url')));
     44                } elseif ($input->getOption('from-list')) {
     45                        $this->addTodo(explode(',', $input->getOption('from-list')));
     46                } elseif ($input->getArgument('from')) {
     47                        $from = $input->getArgument('from');
     48                        foreach ($from as $quoi) {
     49                                if (preg_match(',^https?://,', $quoi)) {
     50                                        $this->addTodo($this->getPrefixesFromUrl($quoi));
     51                                } elseif (strpbrk($quoi, '.\\/')) {
     52                                        $this->addTodo($this->getPrefixesFromFile($quoi));
     53                                } else {
     54                                        $this->addTodo([$quoi]);
     55                                }
     56                        }
     57                } elseif ($input->getOption('all')) {
     58                        $this->addTodo(array_column($this->getPluginsInactifs(), 'nom'));
     59                } else {
     60                        $plugins = $this->getPrefixesFromQuestion();
     61                        if (!$plugins) {
     62                                $this->showHelp($input, $output);
    7463                                return;
    7564                        }
    76 
    77             if ( ! $plugins) {
    78 
    79                 /* Si pas de plugin(s) spécifiés, on demande */
    80                 $helper = $this->getHelper('question');
    81                 $question = new Question("Quel plugin faut-il activer ?\n", 'help');
    82                 $question->setAutoCompleterValues(array_map('strtolower', $inactifs));
    83 
    84                 $reponse = trim($helper->ask($input, $output, $question));
    85                 /* Si même après avoir demandé, l'utilisateur n'a pas
    86                    donné de plugin à activer, on affiche l'aide. */
    87                 if ($reponse == 'help') {
    88                     $command = $this->getApplication()->find('help');
    89                     $arguments = array(
    90                         'command' => 'help',
    91                         'command_name' => 'plugins:activer',
    92                     );
    93                     $input = new ArrayInput($arguments);
    94                     $command->run($input, $output);
    95                     return;
    96                 }
    97 
    98                 $plugins = explode(' ', $reponse);
    99             }
    100 
    101             /* On liste le(s) plugin(s) qui seront activés et on
    102                demande confirmation. */
    103             $helper = $this->getHelper('question');
    104 
    105                         if (!$input->getOption('yes')) {
    106                                 $confirmer = new ConfirmationQuestion("Vous allez activer les plugins suivants : " . implode(', ', $plugins) . ".\nÊtes-vous certain-e de vouloir continuer ? ", false);
    107 
    108                                 if ( ! $helper->ask($input, $output, $confirmer)) return;
    109                         }
    110 
    111             /* Et enfin, on désactive le(s) plugin(s) */
    112             $dir_un = array();
    113             foreach ($plugins as $prefixe) {
    114                 if ( ! in_array($prefixe, $disponibles)) {
    115                     $output->writeln("<error>Le plugin $prefixe est introuvable dans les plugins disponibles.</error>");
    116                 } else if ( ! in_array($prefixe, $inactifs)) {
    117                     $output->writeln("<comment>Le plugin $prefixe est déjà activé.</comment>");
    118                 } else {
    119                     include_spip('base/abstract_sql');
    120                     $p = sql_fetsel('src_archive, constante', 'spip_paquets', array('constante!=""', 'prefixe='.sql_quote($prefixe)));
    121 
    122                     $dir = constant($p['constante']) . $p['src_archive'];
    123                     $output->writeln("<info>Active le plugin $prefixe (repertoire $dir)</info>");
    124 
    125                     $dirs_un[] = $p['src_archive'];
    126                 }
    127             }
    128 
    129             if (count($dirs_un)){
    130                 include_spip('inc/plugin');
    131                 ecrire_plugin_actifs($dirs_un,false,'ajoute');
    132                 /* actualiser la liste des paquets locaux */
    133                 include_spip('inc/svp_depoter_local');
    134                 /*sans forcer tout le recalcul en base, mais en
    135                   récupérant les erreurs XML */
    136                 $err = array();
    137                 svp_actualiser_paquets_locaux(false, $err);
    138                 if ($err) {
    139                     $output->writeln("<error>Erreur XML $err</error>");
    140                 }
    141             }
    142 
    143             chdir($cwd);
    144 
    145         } else {
    146 
    147             $output->writeln("<comment>Vous n'êtes pas dans un installation de SPIP, il n'y a pas de plugins disponibles.</comment>");
    148 
    149         }
    150     }
     65                        $this->addTodo($plugins);
     66                }
     67
     68                if (!$liste = $this->getTodo()) {
     69                        $this->io->care("Aucun prefixe à activer");
     70                        return;
     71                }
     72                $this->io->text("Liste des plugins à activer :");
     73                $this->presenterListe($liste);
     74
     75                if (
     76                        !$input->getOption('yes')
     77                        and !$this->io->confirm("Les plugins listés au-dessus seront activés. Confirmez-vous ?", false)
     78                ) {
     79                        $this->io->care("Action annulée");
     80                        return;
     81                }
     82
     83                $this->actualiserPlugins();
     84                $this->activePlugins($liste);
     85        }
     86
     87        /* Si pas de plugin(s) spécifiés, on demande */
     88        public function getPrefixesFromQuestion() {
     89                $io = $this->io;
     90                $inactifs = array_map('strtolower', array_column($this->getPluginsInactifs(), 'nom'));
     91                $question = new Question("Quel plugin faut-il activer ?\n", 'help');
     92                $question->setAutoCompleterValues($inactifs);
     93                $reponse = trim($io->askQuestion($question));
     94                if ($reponse === 'help') {
     95                        return false;
     96                }
     97                return explode(' ', $reponse);
     98        }
     99
     100        public function showHelp(InputInterface $input, OutputInterface $output) {
     101                $command = $this->getApplication()->find('help');
     102                $arguments = array(
     103                        'command' => 'help',
     104                        'command_name' => 'plugins:activer',
     105                );
     106                $input = new ArrayInput($arguments);
     107                $command->run($input, $output);
     108        }
     109
     110        function confirmerActivation(InputInterface $input) {
     111
     112                /* Et enfin, on désactive le(s) plugin(s) */
     113                $dir_un = array();
     114                foreach ($plugins as $prefixe) {
     115                        if (!in_array($prefixe, $disponibles)) {
     116                                $output->writeln("<error>Le plugin $prefixe est introuvable dans les plugins disponibles.</error>");
     117                        } else if (!in_array($prefixe, $inactifs)) {
     118                                $output->writeln("<comment>Le plugin $prefixe est déjà activé.</comment>");
     119                        } else {
     120                                include_spip('base/abstract_sql');
     121                                $p = sql_fetsel('src_archive, constante', 'spip_paquets', array('constante!=""', 'prefixe=' . sql_quote($prefixe)));
     122
     123                                $dir = constant($p['constante']) . $p['src_archive'];
     124                                $output->writeln("<info>Active le plugin $prefixe (repertoire $dir)</info>");
     125
     126                                $dirs_un[] = $p['src_archive'];
     127                        }
     128                }
     129
     130                if (count($dirs_un)) {
     131                        include_spip('inc/plugin');
     132                        ecrire_plugin_actifs($dirs_un, false, 'ajoute');
     133                        /* actualiser la liste des paquets locaux */
     134                        include_spip('inc/svp_depoter_local');
     135                        /*sans forcer tout le recalcul en base, mais en
     136                          récupérant les erreurs XML */
     137                        $err = array();
     138                        svp_actualiser_paquets_locaux(false, $err);
     139                        if ($err) {
     140                                $output->writeln("<error>Erreur XML $err</error>");
     141                        }
     142                }
     143
     144        }
     145
     146        /**
     147         * Chercher un fichier qui contient la liste des préfixes à activer
     148         *
     149         * En mutualisation, chercher de préférence un fichier relatif au site
     150         *
     151         * @param string $file
     152         * @return string[]
     153         * @throws \Exception
     154         */
     155        public function getPrefixesFromFile($file) {
     156                if (
     157                        $file
     158                        and defined('_DIR_SITE')
     159                        and is_file(_DIR_SITE . $file)
     160                ) {
     161                        $file = _DIR_SITE . $file;
     162                } elseif (!is_file($file)) {
     163                        throw new \Exception("File doesn't exists : " . $file);
     164                }
     165                $list = file_get_contents($file);
     166                return explode(' ', $list);
     167        }
     168
     169        public function getPrefixesFromUrl($url) {
     170                // si on a un fichier local/config.txt on le prend en priorite
     171                exec("curl -L --silent $url/local/config.txt", $head);
     172                $head = implode("\n", $head) . "\n";
     173                if (!preg_match(",^Composed-By:(.*)\n,Uims", $head, $m)) {
     174                        exec("curl -I -L --silent $url", $head);
     175                        $head = implode("\n", $head);
     176                }
     177                if (preg_match(",^Composed-By:(.*)\n,Uims", $head, $m)) {
     178                        // virer les numeros de version
     179                        $liste = preg_replace(",\([^)]+\),", "", $m[1]);
     180                        $liste = explode(",", $liste);
     181                        $liste = array_map('trim', $liste);
     182                        array_shift($liste);
     183                }
     184                return $liste;
     185        }
     186
     187        public function addTodo(array $prefixes) {
     188                $prefixes = array_map('trim', $prefixes);
     189                $prefixes = array_map('strtolower', $prefixes);
     190                $this->todo = array_unique(array_merge($this->todo, $prefixes));
     191        }
     192
     193        public function getTodo() {
     194                return $this->todo;
     195        }
     196
     197        public function activePlugins($prefixes) {
     198                if (!count($prefixes)) {
     199                        $this->io->care("Aucun prefixe à activer");
     200                        return true;
     201                }
     202                $actifs = array_keys($this->getPluginsActifs());
     203                $actifs = array_map('strtolower', $actifs);
     204
     205                if ($deja = array_intersect($actifs, $prefixes)) {
     206                        $prefixes = array_diff($prefixes, $actifs);
     207                        if ($prefixes) {
     208                                $this->io->text("Certains préfixes demandés sont déjà actifs :");
     209                                $this->presenterListe($deja);
     210                        } else {
     211                                $this->io->check("Tous les préfixes demandés sont déjà actifs");
     212                                return true;
     213                        }
     214                }
     215
     216                $inactifs = $this->getPluginsInactifs();
     217                $activer = [];
     218                foreach ($inactifs as $plugin) {
     219                        $prefixe = strtolower($plugin['nom']);
     220                        if (in_array($prefixe, $prefixes)) {
     221                                $activer[] = $plugin['dir'];
     222                                $prefixes = array_diff($prefixes, [$prefixe]);
     223                        }
     224                }
     225
     226                if (count($prefixes)) {
     227                        $this->io->fail("Certains préfixes demandés sont introuvables :");
     228                        $this->presenterListe($prefixes);
     229                }
     230
     231                if (count($activer)) {
     232                        ecrire_plugin_actifs($activer, false, 'ajoute');
     233                        $actifs = $this->getPluginsActifs(['procure' => false, 'php' => false]);
     234                        $this->io->text("Plugins actifs après action :");
     235                        $this->showPlugins($actifs);
     236                        $this->actualiserSVP();
     237                }
     238        }
     239
     240        public function actualiserSVP() {
     241                /* actualiser la liste des paquets locaux */
     242                include_spip('inc/svp_depoter_local');
     243                /* sans forcer tout le recalcul en base, mais en
     244                  récupérant les erreurs XML */
     245                $err = array();
     246                svp_actualiser_paquets_locaux(false, $err);
     247                if ($err) {
     248                        $this->io->care("Erreurs XML présentes :");
     249                        $this->io->care($err);
     250                }
     251        }
    151252}
  • _outils_/spip-cli/trunk/src/Command/PluginsLister.php

    r110792 r110794  
    168168
    169169        public function getPluginsInactifs() {
     170                include_spip('inc/plugin');
    170171                // chercher dans les plugins dispo
    171172                $get_infos = charger_fonction('get_infos','plugins');
Note: See TracChangeset for help on using the changeset viewer.