Changeset 94765 in spip-zone


Ignore:
Timestamp:
Jan 27, 2016, 8:46:04 AM (4 years ago)
Author:
fil@…
Message:

spip server:locate, une commande pour reperer tous les spip installes sur un serveur
la commande liste les sites et quelques infos de base (elle a vocation surtout à lister ce qui a trait aux versions, dates, obsolescence)

File:
1 copied

Legend:

Unmodified
Added
Removed
  • _outils_/spip-cli/trunk/spip-cli/ServerLocate.php

    r94762 r94765  
    77use Symfony\Component\Console\Output\OutputInterface;
    88
    9 class CoreInstaller extends Command {
     9class ServerLocate extends Command {
    1010        protected function configure() {
    1111                $this
    12                         ->setName('core:installer')
    13                         ->setDescription('Installer la base de données et le premier utilisateur.')
     12                        ->setName('server:locate')
     13                        ->setDescription('Localiser les SPIP installés sur ce serveur')
    1414                        ->setAliases(array(
    15                                 'installer',
    16                                 'install',
    1715                        ))
    18                         ->addOption(
    19                                 'db-server',
    20                                 'ds',
    21                                 InputOption::VALUE_OPTIONAL,
    22                                 'Type du serveur SQL',
    23                                 ''
    24                         )
    25                         ->addOption(
    26                                 'db-host',
    27                                 'dh',
    28                                 InputOption::VALUE_OPTIONAL,
    29                                 'Adresse du serveur SQL',
    30                                 'localhost'
    31                         )
    32                         ->addOption(
    33                                 'db-login',
    34                                 'dl',
    35                                 InputOption::VALUE_OPTIONAL,
    36                                 'Identifiant au serveur SQL',
    37                                 ''
    38                         )
    39                         ->addOption(
    40                                 'db-pass',
    41                                 'dp',
    42                                 InputOption::VALUE_OPTIONAL,
    43                                 'Mot de passe pour le serveur SQL',
    44                                 ''
    45                         )
    46                         ->addOption(
    47                                 'db-database',
    48                                 'dd',
    49                                 InputOption::VALUE_OPTIONAL,
    50                                 'Nom de la base de données',
    51                                 'spip'
    52                         )
    53                         ->addOption(
    54                                 'db-prefix',
    55                                 'dx',
    56                                 InputOption::VALUE_OPTIONAL,
    57                                 'Préfixe des tables de SPIP',
    58                                 'spip'
    59                         )
    60                         ->addOption(
    61                                 'admin-nom',
    62                                 'an',
    63                                 InputOption::VALUE_OPTIONAL,
    64                                 'Nom du premier utilisateur',
    65                                 'Admin'
    66                         )
    67                         ->addOption(
    68                                 'admin-login',
    69                                 'al',
    70                                 InputOption::VALUE_OPTIONAL,
    71                                 'Identifiant du premier utilisateur',
    72                                 'admin'
    73                         )
    74                         ->addOption(
    75                                 'admin-email',
    76                                 'ae',
    77                                 InputOption::VALUE_OPTIONAL,
    78                                 'Adresse email du premier utilisateur',
    79                                 'admin@spip'
    80                         )
    81                         ->addOption(
    82                                 'admin-pass',
    83                                 'ap',
    84                                 InputOption::VALUE_OPTIONAL,
    85                                 'Mot de passe du premier utilisateur',
    86                                 'adminadmin'
    87                         )
    8816                ;
    8917        }
    9018       
    9119        protected function execute(InputInterface $input, OutputInterface $output) {
    92                 global $spip_racine;
    93         global $spip_loaded;
    94                
    95                 if (!$spip_loaded) {
    96                         $output->writeln('<error>Vous devez télécharger SPIP avant de pouvoir l’installer.</error>');
     20
     21                $sites = array_merge(
     22                        $this->locate('inc_version.php'),
     23                        $this->locate('inc_version.php3')
     24                );
     25
     26                if (!count($sites)) {
     27                        $output->writeln('<error>Pas de site SPIP détecté.</error>');
     28                        exit;
    9729                }
    98                
    99                 // Si les fichiers de SPIP sont bien là
    100                 if ($spip_loaded) {
    101                         // Charger les librairies nécessaires
    102                         include_spip('inc/install');
    103                         include_spip('inc/autoriser');
    104                         include_spip('base/create');
    105                         include_spip('inc/filtres');
    106                         include_spip('inc/charsets');
    107                         include_spip('auth/sha256.inc');
    108                         include_spip('inc/acces');
    109                         include_spip('inc/plugin');
    110                         // Préciser qu'on est dans l'installation
    111                         define('_ECRIRE_INSTALL', "1");
    112                         define('_FILE_TMP', '_install');
    113                        
    114                         // On teste si c'est déjà bien installé
    115                         $deja = (_FILE_CONNECT AND analyse_fichier_connection(_FILE_CONNECT));
    116                         if ($deja) {
    117                                 $output->writeln('<info>La base de SPIP est déjà installée correctement.</info>');
    118                         }
    119                         // Sinon on essaye d'installer la base
    120                         else {
    121                                 // Récupération des options pour la base
    122                                 $db_server = $input->getOption('db-server');
    123                                 $db_host = $input->getOption('db-host');
    124                                 $db_login = $input->getOption('db-login');
    125                                 $db_pass = $input->getOption('db-pass');
    126                                 $db_database = $input->getOption('db-database');
    127                                 $db_prefix = $input->getOption('db-prefix');
    128                                 if ($db_prefix) { set_request('tprefix', $db_prefix); }
    129                                
    130                                 // Liste des serveurs SQL disponibles
    131                                 $serveurs = install_select_serveur();
    132                                 foreach ($serveurs as $k=>$v) {
    133                                         if (preg_match('/value=(\'|")(.*?)\1/is', $v, $serveur)) {
    134                                                 $serveurs[$k] = $serveur[2];
    135                                         }
    136                                 }
    137                                
    138                                 // Valeur par défaut du serveur SQL si aucun défini
    139                                 if (!$db_server) {
    140                                         // Si sqlite3 est disponible on le met par défaut
    141                                         if (in_array('sqlite3', $serveurs)) {
    142                                                 $db_server = 'sqlite3';
    143                                         }
    144                                         // Sinon on prend le premier de la liste
    145                                         else {
    146                                                 $db_server = $serveurs[0];
    147                                         }
    148                                 }
    149                                
    150                                 // Uniquement si pas SQLite, valeur par défaut pour le login
    151                                 if (!preg_match('/sqlite.*/i', $db_server)) {
    152                                         if (!$db_login) {
    153                                                 $db_login = 'root';
    154                                         }
    155                                 }
    156                                 // Unique si SQLite, on lève un drapeau
    157                                 else {
    158                                         $flag_sqlite = true;
    159                                 }
    160                                
    161                                 // Si le type de serveur ne fait pas partie de la liste, on arrête
    162                                 if (!in_array($db_server, $serveurs)) {
    163                                         $output->writeln("<error>Les serveurs de type \"$db_server\" ne sont pas gérés.</error>");
    164                                         return;
    165                                 }
    166                                
    167                                 // Si on n'arrive pas à se connecter à la base définie, on arrête
    168                                 if (!$db_test = spip_connect_db($db_host, 0, $db_login, $db_pass, $db_database, $db_server)) {
    169                                         $output->writeln('<error>Impossible de se connecter à la base de données.</error>');
    170                                         return;
    171                                 }
    172                                
    173                                 // On est bien connecté, on va pouvoir installer la base !
    174                                 include_spip('install/etape_3');
    175                                
    176                                 // Enregistrement dans les connexions de SPIP
    177                                 $GLOBALS['connexions'][$db_server] = $db_test;
    178                                 $GLOBALS['connexions'][$db_server][$GLOBALS['spip_sql_version']] = $GLOBALS['spip_' . $db_server .'_functions_' . $GLOBALS['spip_sql_version']];
    179                                
    180                                 // On prévient qu'on démarre l'installation
    181                                 $output->writeln(array(
    182                                         "<info>Connexion à la base de données établie :</info> <comment>$db_server version ".sql_version($db_server).'</comment>',
    183                                         "\nDémarrage de l’installation de la base…",
    184                                 ));
    185                                
    186                                 // Si l'installation de la base renvoie une chaîne, c'est une erreur, on arrête
    187                                 if (
    188                                         $erreur = install_bases($db_host, $db_login, $db_pass, $db_server, $db_database, $db_database, _SPIP_CHMOD)
    189                                         and is_string($erreur)
    190                                 ) {
    191                                         // On reformate la chaîne pour la ligne de commande
    192                                         $erreur = str_replace('<!--', 'ERREURDEBUT', $erreur);
    193                                         $erreur = str_replace('!>', 'ERREURFIN', $erreur);
    194                                         $erreur = textebrut($erreur);
    195                                         $erreur = str_replace('ERREURDEBUT', '<error>', $erreur);
    196                                         $erreur = str_replace('ERREURFIN', '</error>', $erreur);
    197                                         $output->writeln(array(
    198                                                 '<error>Erreur lors de l’installation :</error>',
    199                                                 $erreur,
    200                                                 '<comment>Veuillez recommencer l’installation.</comment>',
    201                                         ));
    202                                         return;
    203                                 }
    204                                
    205                                 // Si le fichier de connexion temporaire n'est pas bien créé
    206                                 if (!file_exists(_FILE_CONNECT_TMP)) {
    207                                         $output->writeln(array(
    208                                                 '<error>Le fichier de connexion n’a pas été créé correctement.</error>',
    209                                                 '<comment>Veuillez recommencer l’installation.</comment>',
    210                                         ));
    211                                         return;
    212                                 }
    213                                
    214                                 // On inclue le fichier temporaire
    215                                 include(_FILE_CONNECT_TMP);
    216                                 // Si SQLite on change les droits du fichier de la base, pour être sûr !
    217                                 if ($flag_sqlite) {
    218                                         chmod("config/bases/$db_database.sqlite", _SPIP_CHMOD);
    219                                 }
    220                                 // On affirme que tout s'est bien passé
    221                                 $output->writeln("<info>La base de données a bien été installée.</info>");
    222                         }
    223                        
    224                         // À ce niveau, la base est bien installée ! On va pouvoir ajouter le premier admin
    225                         $output->writeln("\nInstallation d'un admin…");
    226                        
    227                         // On récupère les informations du premier admin
    228                         $nom = $input->getOption('admin-nom');
    229                         $login = $input->getOption('admin-login');
    230                         $pass = $input->getOption('admin-pass');
    231                         $email = $input->getOption('admin-email');
    232                        
    233                         // Si le mot de passe est trop court, on arrête
    234                         if (strlen($pass) < _PASS_LONGUEUR_MINI) {
    235                                 $output->writeln('<error>'._T('info_passe_trop_court_car_pluriel', array('nb'=>_PASS_LONGUEUR_MINI)).'</error>');
    236                                 return;
    237                         }
    238                        
    239                         // Si le login est trop court, on arrête
    240                         if (strlen($login) < _LOGIN_TROP_COURT) {
    241                                 $output->writeln('<error>'._T('info_login_trop_court').'</error>');
    242                                 return;
    243                         }
    244                        
    245                         // Si l'email n'a pas la bonne forme, on arrête
    246                         if (!email_valide($email)) {
    247                                 $output->writeln('<error>'._T('form_email_non_valide').'</error>');
    248                                 return;
    249                         }
    250                        
    251                         // On peut ajouter l'admin
    252                         if ($id_auteur = $this->ajouter_admin($nom, $login, $pass, $email) and $id_auteur > 0){
    253                                 $output->writeln("<info>« $nom » est bien admin du site (ID $id_auteur).</info>");
    254                         }
    255                         else {
    256                                 $output->writeln("<error>Erreur lors de l'ajout d'un admin « $nom ».</error>");
    257                         }
    258                        
    259                         // Installer les metas
    260                         $output->write("\nInstallation des configurations par défaut… ");
    261                         $config = charger_fonction('config', 'inc');
    262                         $config();
    263                         $output->writeln("<info>OK</info>");
    264                        
    265                         // Créer le répertoire cache, qui sert partout !
    266                         if(!@file_exists(_DIR_CACHE)) {
    267                                 $rep = preg_replace(','._DIR_TMP.',', '', _DIR_CACHE);
    268                                 $rep = sous_repertoire(_DIR_TMP, $rep, true,true);
    269                         }
    270                        
    271                         // Activer les plugins-dist
    272                         $output->writeln("\nInstallation des plugins-dist… ");
    273                         // Si on obtient bien une liste de plugins, on l'affiche
    274                         if ($plugins = $this->installer_plugins($input, $output)) {
    275                                 $output->writeln('<info>Les plugins suivants sont activés :</info>');
    276                                 foreach ($plugins as $plugin){
    277                                         if (isset($plugin['nom'])) {
    278                                                 $output->writeln("\t<comment>${plugin['nom']} (${plugin['version']})</comment>");
    279                                         }
    280                                 }
    281                         }
    282                        
    283                         // Finitions
    284                         $this->finir_installation();
    285                        
    286                         // Vérifier la securité des htaccess
    287                         // Si elle ne fonctionne pas, prévenir
    288                         if ($erreur = $this->verifier_htaccess($input, $output)) {
    289                                 $output->writeln('<comment>'.$erreur.'</comment>');
    290                         }
     30
     31                foreach($sites as $site) {
     32                        $msg = $this->analyser_site($site);
     33                        if ($msg)
     34                                $output->writeln($msg);
    29135                }
    29236        }
    29337       
    29438        /**
    295          * Ajouter un⋅e premier⋅e admin
     39         * Cherche les fichiers nommés xxxx
    29640         *
    297          * @return int Retourne l'identifiant de l'utilisateur créé si ça s'est bien passé
     41         * @return array liste des fichiers nommés xxxx
    29842         */
    299         protected function ajouter_admin($nom, $login, $pass, $email) {
    300                 lire_metas();
    301                 $nom = (importer_charset($nom, _DEFAULT_CHARSET));
    302                 $login = (importer_charset($login, _DEFAULT_CHARSET));
    303                 $email = (importer_charset($email, _DEFAULT_CHARSET));
    304                 # pour le passwd, bizarrement il faut le convertir comme s'il avait
    305                 # ete tape en iso-8859-1 ; car c'est en fait ce que voit md5.js
    306                 $pass = unicode2charset(utf_8_to_unicode($pass), 'iso-8859-1');
    307                 $htpass = generer_htpass($pass);
    308                 $alea_actuel = creer_uniqid();
    309                 $alea_futur = creer_uniqid();
    310                 $shapass = _nano_sha256($alea_actuel.$pass);
     43        protected function locate($filename) {
     44                $_filename = escapeshellarg($filename);
     45                $files = `locate $_filename 2>/dev/null`
     46                 . `mdfind -name $_filename 2>/dev/null`;
     47                $files = explode("\n", trim($files));
     48                $files = array_filter($files, function($x) {
     49                        return preg_match(",/inc_version\.php[3]?$,", $x);
     50                });
    31151               
    312                 // prelablement, creer le champ webmestre si il n'existe pas (install neuve
    313                 // sur une vieille base
    314                 $t = sql_showtable("spip_auteurs", true);
    315                 if (!isset($t['field']['webmestre'])) {
    316                         @sql_alter("TABLE spip_auteurs ADD webmestre varchar(3)  DEFAULT 'non' NOT NULL");
    317                 }
    318                
    319                 $id_auteur = sql_getfetsel("id_auteur", "spip_auteurs", "login=" . sql_quote($login));
    320                 if ($id_auteur !== NULL) {
    321                         sql_updateq('spip_auteurs', array("nom"=> $nom, 'email'=> $email, 'login'=>$login, 'pass'=>$shapass, 'alea_actuel'=>$alea_actuel, 'alea_futur'=> $alea_futur, 'htpass'=>$htpass, 'statut'=>'0minirezo'), "id_auteur=$id_auteur");
    322                 }
    323                 else {
    324                         $id_auteur = sql_insertq('spip_auteurs', array(
    325                                 'nom' => $nom,
    326                                 'email' => $email,
    327                                 'login' => $login,
    328                                 'pass' => $shapass,
    329                                 'htpass' => $htpass,
    330                                 'alea_actuel' => $alea_actuel,
    331                                 'alea_futur' => $alea_futur,
    332                                 'statut' =>'0minirezo'
    333                         ));
    334                 }
    335                
    336                 // le passer webmestre separrement du reste, au cas ou l'alter n'aurait pas fonctionne
    337                 @sql_updateq('spip_auteurs', array('webmestre' => 'oui'), "id_auteur=$id_auteur");
    338                
    339                 // inserer email comme email webmaster principal
    340                 // (sauf s'il est vide: cas de la re-installation)
    341                 if ($email) {
    342                         ecrire_meta('email_webmaster', $email);
    343                 }
    344                
    345                 return $id_auteur;
     52                return $files;
    34653        }
    347        
    348         /**
    349          * Installation des plugins actifs (pour les plugins-dist)
    350          *
    351          * @return void
    352          */
    353         protected function installer_plugins($input, $output) {
    354                 actualise_plugins_actifs();
    355                 chmod(_CACHE_PIPELINES, _SPIP_CHMOD);
    356                
    357                 $installer_plugins = charger_fonction('installer', 'plugins');
    358                 $meta_plug_installes = array();
    359                 foreach (unserialize($GLOBALS['meta']['plugin']) as $prefix=>$resume) {
    360                         if ($plug = $resume['dir']){
    361                                 $infos = $installer_plugins($plug, 'install', $resume['dir_type']);
    362                                 if ($infos){
    363                                         if (!is_array($infos) OR $infos['install_test'][0])
    364                                                 $meta_plug_installes[] = $plug;
    365                                         if (is_array($infos)){
    366                                                 list($ok, $trace) = $infos['install_test'];
    367                                                 $output->writeln("\tInstallation du plugin ${infos['nom']}… ".($ok ? '<info>OK</info>' : '<error>Erreur</error>'));
    368                                         }
    369                                 }
    370                         }
    371                 }
    372                 ecrire_meta('plugin_installes',serialize($meta_plug_installes),'non');
    373                
    374                 appliquer_adresse_site('');
    375                 return lire_config('plugin',array());
    376         }
    377        
    378         /**
    379          * Finitions de l'installation
    380          *
    381          * @return void
    382          */
    383         protected function finir_installation() {
    384                 ecrire_acces();
    38554
    386                 $f = str_replace( _FILE_TMP_SUFFIX, '.php', _FILE_CHMOD_TMP);
    387                 if (file_exists(_FILE_CHMOD_TMP)) {
    388                         if (!@rename(_FILE_CHMOD_TMP, $f)) {
    389                                 if (@copy(_FILE_CHMOD_TMP, $f))
    390                                         spip_unlink(_FILE_CHMOD_TMP);
    391                         }
     55        protected function analyser_site($filename) {
     56                $inc_version = basename($filename);
     57                $ecrire = basename(dirname($filename));
     58                $rep = dirname(dirname($filename));
     59                $name = basename($rep);
     60
     61                $a = @file_get_contents($filename);
     62
     63                if (preg_match('/.*spip_version_branche\s*=\s*[\'"](.*)[\'"];/', $a, $r)
     64                OR preg_match('/.*spip_version_affichee\s*=\s*[\'"](.*)[\'"];/', $a, $r)) {
     65                        $version_spip = $r[1];
     66                } else {
     67                        $version_spip = "<error>version?</error>";
    39268                }
    39369
    394                 $f = str_replace( _FILE_TMP_SUFFIX, '.php', _FILE_CONNECT_TMP);
    395                 if (file_exists(_FILE_CONNECT_TMP)) {
    396                         spip_log("renomme $f");
    397                         if (!@rename(_FILE_CONNECT_TMP, $f)) {
    398                                 if (@copy(_FILE_CONNECT_TMP, $f))
    399                                         @spip_unlink(_FILE_CONNECT_TMP);
    400                         }
    401                 }
     70                $report = [
     71                        "Version" => $version_spip,
     72                        "Répertoire" => $rep,
     73                ];
     74
     75
     76                // Regarder les bases de données connectées, etc, etc.
     77                // TODO
     78
     79
     80                // Données à afficher
     81                $aff =  "<info>$name</info> ($version_spip)\n";
     82                foreach($report as $key => $val)
     83                        $aff .= "  $key: $val\n";
     84
     85                return $aff;
    40286        }
    403        
    404         /**
    405          * Vérifier la securité des htaccess
    406          *
    407          * @return string Retourne un message d'erreur si ça ne va pas
    408          */
    409         protected function verifier_htaccess() {
    410                 if (
    411                         !verifier_htaccess(_DIR_TMP, true)
    412                         or !verifier_htaccess(_DIR_CONNECT, true)
    413                 ) {
    414                         return _T('htaccess_inoperant');
    415                 }
    416                
    417                 return '';
    418         }
     87
    41988}
Note: See TracChangeset for help on using the changeset viewer.