Changeset 85955 in spip-zone


Ignore:
Timestamp:
Nov 10, 2014, 2:16:00 PM (5 years ago)
Author:
marcimat@…
Message:

Découpage des fonctions de migration pour mieux s'y retrouver avec ces nouvelles options par ssh.

Ça devrait rien casser de ce qui existait.

Location:
_plugins_/migrateur/trunk
Files:
5 added
7 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/migrateur/trunk/CHANGELOG.md

    r85410 r85955  
    22=========
    33
    4 Version 1.4
     4Version 2.5
     5-----------
     6
     7- restructuration du code pour plus de clarté.
     8- compatible SPIP 3.1
     9
     10
     11Version 2.4
    512-----------
    613
     
    815- l'export de la bdd peut se faire sur un serveur distant
    916
    10 Version 1.3
     17Version 2.3
    1118-----------
    1219
  • _plugins_/migrateur/trunk/inc/migrateur.php

    r85409 r85955  
    11<?php
    22
     3/**
     4 * Fonctions outils pour le migrateur
     5 *
     6 * @package SPIP\Migrateur\Fonctions
     7**/
     8
    39if (!defined("_ECRIRE_INC_VERSION")) return;
     10
     11include_spip('inc/migrateur_aide');
     12include_spip('inc/Migrateur_SSH');
     13include_spip('inc/Migrateur_SQL');
     14include_spip('inc/Migrateur_DATA');
     15
     16
     17
     18/**
     19 * Retourne les données d'accès au serveur source
     20 *
     21 * Si elles sont là, on les retoune
     22 *
     23 * @uses migrateur_data()
     24 * @return null|Migrateur_DATA
     25 *     Données de connexions si définies
     26**/
     27function migrateur_source() {
     28        return migrateur_data('source');
     29}
     30
     31
     32/**
     33 * Retourne les données d'accès au serveur destination
     34 *
     35 * Si elles sont là, on les retoune
     36 *
     37 * @uses migrateur_data()
     38 * @return null|Migrateur
     39 *     Données de connexions si définies
     40**/
     41function migrateur_destination() {
     42        return migrateur_data('destination');
     43}
     44
     45
     46/**
     47 * Retourne les données d'accès au serveur source ou destination
     48 *
     49 * Si elles sont là, on les retoune
     50 *
     51 * @uses migrateur_data()
     52 * @param string $type
     53 *     Type de données désirées (source | destination)
     54 * @return null|Migrateur_DATA
     55 *     Données de connexions si définies
     56**/
     57function migrateur_data($type) {
     58        static $migs = array();
     59
     60        $type = strtoupper($type);
     61
     62        if (isset($migs[$type])) {
     63                return $migs[$type];
     64        }
     65
     66        $props = array();
     67
     68        foreach (array(
     69                "MIGRATEUR_{$type}_DIR" => 'dir',
     70
     71                "MIGRATEUR_{$type}_SQL_USER"        => 'sql/user',
     72                "MIGRATEUR_{$type}_SQL_PASS"        => 'sql/pass',
     73                "MIGRATEUR_{$type}_SQL_BDD"         => 'sql/bdd',
     74                "MIGRATEUR_{$type}_SQL_LOGIN_PATH"  => 'sql/login_path',
     75
     76                "MIGRATEUR_{$type}_SSH_SERVER"      => 'ssh/server',
     77                "MIGRATEUR_{$type}_SSH_USER"        => 'ssh/user',
     78                "MIGRATEUR_{$type}_SSH_PORT"        => 'ssh/port',
     79        ) as $const => $prop) {
     80                if (defined($const) and constant($const)) {
     81                        // 'ssh/server' => group 'ssh' et clé 'server'
     82                        $keys = explode('/', $prop);
     83                        if (count($keys) > 1) {
     84                                $group = array_shift($keys);
     85                                $prop = array_shift($keys);
     86                                if (!isset($props[$group])) {
     87                                        $props[$group] = array();
     88                                }
     89                                $props[$group][$prop] = constant($const);
     90                        } else {
     91                                $props[$prop] = constant($const);
     92                        }
     93                }
     94        }
     95
     96        return $migs[$type] = new Migrateur_DATA($props);
     97}
     98
    499
    5100
     
    26121
    27122
    28 /**
    29  * Stocker les données de connexion à un serveur via ssh
    30 **/
    31 class Migrateur_SSH {
    32         private $server = '';
    33         private $port = 22;
    34         private $user = '';
    35 
    36         /**
    37          * Constructeur.
    38          *
    39          * Permet de passer un tableau de couples de données (cle => valeur)
    40         **/
    41         public function __construct($props = array()) {
    42                 if (is_array($props)) {
    43                         foreach($props as $prop => $val) {
    44                                 if (property_exists($this, $prop)) {
    45                                         $this->$prop = $val;
    46                                 }
    47                         }
    48                 }
    49         }
    50 
    51         /**
    52          * Permet d'obtenir une propriété de la classe
    53         **/
    54         public function __get($prop) {
    55                 if (!property_exists($this, $prop)) {
    56                         throw new Exception("Paramètre " . $prop . " inconnu");
    57                 }
    58                 return $this->$prop;
    59         }
    60 
    61         /**
    62          * Retourne la commande d'exécution pour se connecter à ce serveur
    63          *
    64          * Retourne 'ssh -o StrictHostKeyChecking=no -p XX user@serveur.tld'
    65          * @return string
    66         **/
    67         public function obtenir_commande_serveur() {
    68                 $cmd = migrateur_obtenir_commande_serveur('ssh');
    69                 if (!$cmd) return false;
    70                 return "$cmd -o StrictHostKeyChecking=no -p {$this->port} {$this->user}@{$this->server}";
    71         }
    72 
    73         /**
    74          * Obtient le chemin d'un executable sur un serveur distant.
    75          *
    76          * @example
    77          *     ```
    78          *     $ssh = migrateur_source_ssh();
    79          *     $cmd_ssh = $ssh->obtenir_commande_serveur();
    80          *     $cmd = $ssh->obtenir_commande_serveur_distant('mysqldump');
    81          *     if ($cmd)
    82          *         exec("$cmd_ssh $cmd ...");
    83          *     }
    84          *     ```
    85          * @param string $command
    86          *     Nom de la commande
    87          * @return string
    88          *     Chemin de la commande
    89         **/
    90         function obtenir_commande_serveur_distant($command) {
    91                 static $commands = array();
    92                 if (array_key_exists($command, $commands)) {
    93                         return $commands[$command];
    94                 }
    95        
    96                 $ssh_cmd = $this->obtenir_commande_serveur();
    97                 if (!$ssh_cmd) {
    98                         return $commands[$command] = '';
    99                 }
    100                 exec("$ssh_cmd which $command", $output, $err);
    101                 if (!$err and count($output) and $cmd = trim($output[0])) {
    102                         migrateur_log("Commande distante '$command' trouvée dans $cmd");
    103                         return $commands[$command] = $cmd;
    104                 }
    105                 migrateur_log("/!\ Commande distante '$command' introuvable sur le serveur…");
    106                 return $commands[$command] = '';
    107         }
    108 
    109 }
    110123
    111124/**
     
    118131 * Si elles sont là, on les retoune
    119132 *
     133 * @deprecated Utiliser migrateur_source()->ssh
     134 *
    120135 * @return null|Migrateur_SSH
    121136 *     Données de connexion SSH si définies
    122137**/
    123138function migrateur_source_ssh() {
    124         $props = array();
    125 
    126         foreach (array(
    127                 'MIGRATEUR_SOURCE_SSH_SERVER' => 'server',
    128                 'MIGRATEUR_SOURCE_SSH_USER' => 'user',
    129                 'MIGRATEUR_SOURCE_SSH_PORT' => 'port'
    130         ) as $const => $prop) {
    131                 if (defined($const) and constant($const)) {
    132                         $props[$prop] = constant($const);
    133                 }
    134         }
    135 
    136         if (isset($props['server'])) {
    137                 return new Migrateur_SSH($props);
    138         }
    139 
    140         return null;
     139        $source = migrateur_source();
     140        return $source->ssh;
    141141}
    142142
    143 
    144 /**
    145  * Vider les caches, tous les caches !
    146  *
    147  * Vider le cache de SPIP (voir action/purger.php)
    148 **/
    149 function migrateur_vider_cache() {
    150         migrateur_log("Vider le cache");
    151         include_spip('inc/invalideur');
    152         supprime_invalideurs();
    153         @spip_unlink(_CACHE_RUBRIQUES);
    154         @spip_unlink(_CACHE_PIPELINES);
    155         @spip_unlink(_CACHE_PLUGINS_PATH);
    156         @spip_unlink(_CACHE_PLUGINS_OPT);
    157         @spip_unlink(_CACHE_PLUGINS_FCT);
    158         @spip_unlink(_CACHE_CHEMIN);
    159         @spip_unlink(_DIR_TMP."plugin_xml_cache.gz");
    160         purger_repertoire(_DIR_CACHE,array('subdir'=>true));
    161         purger_repertoire(_DIR_AIDE);
    162         purger_repertoire(_DIR_VAR.'cache-css');
    163         purger_repertoire(_DIR_VAR.'cache-js');
    164         @spip_unlink(_FILE_META);
    165 }
    166143
    167144
     
    169146 * Obtient le chemin d'un executable sur le serveur.
    170147 *
     148 * @deprecated Utiliser migrateur_source()->obtenir_commande_serveur('rsync')
    171149 * @example
    172150 *     ```
     
    182160**/
    183161function migrateur_obtenir_commande_serveur($command) {
    184         static $commands = array();
    185         if (array_key_exists($command, $commands)) {
    186                 return $commands[$command];
    187         }
    188        
    189         exec("which $command", $output, $err);
    190         if (!$err and count($output) and $cmd = trim($output[0])) {
    191                 migrateur_log("Commande '$command' trouvée dans $cmd");
    192                 return $commands[$command] = $cmd;
    193         }
    194         migrateur_log("/!\ Commande '$command' introuvable sur ce serveur…");
    195         return $commands[$command] = '';
     162        $source = migrateur_source();
     163        return $source->obtenir_commande_serveur($command);
    196164}
    197165
    198 
    199 
    200 /**
    201  * Calcule un numéro de branche depuis une version donnée, ou depuis la version de spip actuellement utilisé
    202  *
    203  * @param string $version
    204  *     Numéro de version dont on souhaite le numéro de branche, tel que 2.1.9, 3.0.0-beta2...
    205  *     En absence, prend la version du SPIP actuellement utilisé
    206  * @return string
    207  *     Numéro de branche, exemple : 3.0
    208 **/
    209 function migrateur_obtenir_numero_branche($version = null) {
    210         if (is_null($version)) {
    211                 // 3.0.0-alpha
    212                 $version = $GLOBALS['spip_version_branche'];
    213         }
    214 
    215         // 3.0.0
    216         $version = strtolower(preg_replace(',([0-9])[\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i','\\1', $version));
    217 
    218         // 3.0
    219         $t = explode('.', $version);
    220         return $t[0] . '.' . $t[1];
    221 }
    222 
    223 /**
    224  * Active un ou plusieurs plugins ayant le préfixe indiqué
    225  *
    226  * @param string|array $prefixes
    227  *     Préfixe(s) des plugins
    228  * @param string $redirect
    229  *     URL de redirection, sinon prend dans _request()
    230 **/
    231 function migrateur_activer_plugin_prefixes($prefixes, $redirect=null) {
    232         if (!$prefixes) return false;
    233 
    234         if (is_null($redirect)) {
    235                 $redirect = _request('redirect');
    236         }
    237 
    238         if (!is_array($prefixes)) {
    239                 $prefixes = array($prefixes);
    240         }
    241 
    242         $prefixes_majuscule = array_map('strtoupper', $prefixes);
    243 
    244         // sélectionner uniquement les paquets compatibles avec notre branche !
    245         // [fixme] peut poser problème avec les versions dev : cela va ignorer
    246         // des paquets, même si la constante _DEV_PLUGINS est définie
    247         $branche_spip = migrateur_obtenir_numero_branche();
    248 
    249         $ids_paquets = sql_allfetsel('id_paquet', 'spip_paquets', array(
    250                 sql_in('prefixe', $prefixes_majuscule),
    251                 'obsolete=' . sql_quote('non'),
    252                 'id_depot=' . sql_quote(0),
    253                 'branches_spip REGEXP "(^|,)' . preg_quote($branche_spip) . '($|,)"',
    254         ), 'prefixe', 'etatnum DESC');
    255         if ($ids_paquets) {
    256                 $ids_paquets = array_map('array_shift', $ids_paquets);
    257         } else {
    258                 $ids_paquets = array();
    259         }
    260 
    261         migrateur_log('Activer les paquets : ' . implode(',', $prefixes) . ' ( ' . implode(',', $ids_paquets) . ' )');
    262 
    263         include_spip('inc/svp_decider');
    264         include_spip('inc/svp_actionner');
    265 
    266         $a_actionner = array();
    267         foreach ($ids_paquets as $i) {
    268                 $a_actionner[$i] = 'on';
    269         }
    270 
    271         $decideur = new Decideur;
    272         $decideur->erreur_sur_maj_introuvable = false;
    273         $ok = $decideur->verifier_dependances($a_actionner);
    274 
    275         if (!$ok) {
    276                 migrateur_log('[Erreur] Sur le calcul de dépendance');
    277                 foreach ($decideur->err as $id=>$errs) {
    278                         foreach($errs as $err) {
    279                                 migrateur_log($err);
    280                         }
    281                 }
    282                 return false;
    283         }
    284 
    285         $rien = true;
    286         if ($do = $decideur->presenter_actions('ask')) {
    287                 $rien = false;
    288                 migrateur_log('Plugins demandés :');
    289                 foreach ($do as $desc) { migrateur_log('- ' . $desc); }
    290         }
    291         if ($do = $decideur->presenter_actions('changes')) {
    292                 $rien = false;
    293                 migrateur_log('Actions supplémentaires :');
    294                 foreach ($do as $desc) { migrateur_log('- ' . $desc); }
    295         }
    296 
    297         if ($rien) {
    298                 migrateur_log('[Erreur potentielle !] SVP n\'a rien à faire ?');
    299                 if ($do = $decideur->presenter_actions('todo')) {
    300                         foreach ($do as $desc) { migrateur_log('- ' . $desc); }
    301                 }
    302         }
    303 
    304         // On construit la liste des actions pour la passer au formulaire en hidden
    305         $todo = array();
    306         foreach ($decideur->todo as $_todo) {
    307                 $todo[$_todo['i']] = $_todo['todo'];
    308         }
    309 
    310         $actionneur = new Actionneur();
    311         $actionneur->ajouter_actions($todo);
    312         $actionneur->verrouiller();
    313         $actionneur->sauver_actions();
    314 
    315         $action = generer_url_action('actionner', 'redirect='.urlencode($redirect), '&');
    316         include_spip('inc/headers');
    317         migrateur_log('=> Redirection sur SVP');
    318         redirige_par_entete($action);
    319 }
    320 
    321 
    322 
    323 
    324 
    325 /**
    326  * Déplace le contenu d'une table dans une autre en s'appuyant sur un tableau de correspondance
    327  * des champs, et en supposant que la table destination est vide au départ
    328  *
    329  * @param string $table_source
    330  *     Nom de la table SQL source, tel que 'spip_trucs_old'
    331  * @param string $table_destination
    332  *     Nom de la table SQL source, tel que 'spip_trucs'
    333  * @param array $correspondances
    334  *     Couples de correspondances : nom du champ ancien => nom du champ nouveau.
    335  *     Si le nouveau champ est vide, la colonne ancienne n'est pas importée.
    336  * @param array $options
    337  *     Tableau d'options
    338  *     - string 'callback_ligne' : fonction de callback modifiant une ligne insérée
    339 **/
    340 function migrateur_deplacer_table_complete($table_source, $table_destination, $correspondances = array(), $options = array()) {
    341 
    342         $options = $options + array(
    343                 // fonction de callback modifiant une ligne insérée
    344                 // 'callback_ligne' => 'toto',
    345                 // function toto($données, $anciennes_données) { ... return $donnees; }
    346                 'callback_ligne' => '',
    347         );
    348 
    349         // transposer les donnees dans la nouvelle structure
    350         $inserts = array();
    351         $valeurs = sql_allfetsel('*', $table_source);
    352         if (!is_array($valeurs) OR !$valeurs) {
    353                 migrateur_log("% Insertion dans $table_destination : source $table_source absente ou vide)");
    354                 return true;
    355         }
    356 
    357         // on remet les noms des cles dans le tableau de valeur
    358         // en s'assurant de leur correspondance au passage
    359         $callback = $options['callback_ligne'];
    360         foreach ($valeurs as $v) {
    361                 $i = array();
    362                 foreach ($v as $cle => $valeur) {
    363                         if (isset($correspondances[$cle]) and $correspondances[$cle]) {
    364                                 $i[ $correspondances[$cle] ] = $valeur;
    365                         }
    366                 }
    367                 $inserts[] = $callback ? $callback($i, $v) : $i;
    368         }
    369         unset($valeurs);
    370 
    371         // inserer les donnees en base.
    372         $nb_inseres = 0;
    373         // ne pas reimporter ceux deja la (en cas de timeout)
    374         $nb_deja_la = sql_countsel($table_destination);
    375         $nb_total   = count($inserts);
    376 
    377 
    378         // on ecrit un gentil message pour suivre l'avancement.
    379         migrateur_log("Insertion dans $table_destination (depuis $table_source)");
    380         migrateur_log("  - $nb_deja_la sont déjà là (sur $nb_total)");
    381 
    382         // tout est déjà là !
    383         if ($nb_total == $nb_deja_la) {
    384                 return true;
    385         }
    386 
    387         $inserts = array_slice($inserts, $nb_deja_la);
    388         $nb_a_inserer = count($inserts);
    389 
    390         migrateur_log("  - $nb_a_inserer sont à insérer");
    391 
    392         // on decoupe en petit bout (pour reprise sur timeout)
    393         $inserts = array_chunk($inserts, 100);
    394         foreach ($inserts as $i) {
    395                 sql_insertq_multi($table_destination, $i);
    396                 $nb_inseres += count($i);
    397 
    398                 // serie_alter() relancera la fonction jusqu'a ce que l'on sorte sans timeout.
    399                 if (time() >= _TIME_OUT) {
    400                         // on ecrit un gentil message pour suivre l'avancement.
    401                         migrateur_log("  [relance] Insertion dans $table_destination relancée");
    402                         migrateur_log("  - $nb_inseres ont été insérés");
    403                         $a_faire = $nb_a_inserer - $nb_inseres;
    404                         migrateur_log("  - $a_faire sont à insérer");
    405 
    406                         #$redirect = generer_url_action('migrateur', _request('arg'), true);
    407                         $redirect = url_de_base() . _DIR_RESTREINT_ABS . '?' . $_SERVER['QUERY_STRING'];
    408                         $redirect = parametre_url($redirect, 'redirect', _request('redirect'), '&');
    409                         $redirect = parametre_url($redirect, 'recharger', 1, '&');
    410                         migrateur_log("  --> Recharger \n\n");
    411 
    412                         include_spip('inc/headers');
    413                         #var_dump($redirect); die();
    414                         redirige_par_entete($redirect);
    415                         return false; // aucazou
    416                 }
    417         }
    418 
    419         migrateur_log("  - $nb_inseres ont été insérés");
    420 
    421 
    422         return true;
    423 }
    424 
    425 
    426 /**
    427  * Obtenir dans la base en cours la liste des plugins actifs
    428  * ayant un certain terme dans leur préfixe.
    429  *
    430  * @param string $terme
    431  *     Terme cherché, par exemple 'migrateur'
    432  * @return array
    433  *     Chemins vers les plugins actifs ayant ce terme
    434 **/
    435 function migrateur_obtenir_plugins_actifs($terme) {
    436         migrateur_log("Extraire les plugins actifs ayant '$terme'");
    437         $plugins = array();
    438 
    439         $plugins_actifs = sql_getfetsel('valeur', 'spip_meta', 'nom=' . sql_quote('plugin'));
    440 
    441         if ($plugins_actifs and ($plugins_actifs = unserialize($plugins_actifs))) {
    442                 foreach ($plugins_actifs as $prefixe => $infos ) {
    443                         if (stripos($prefixe, $terme) !== false) {
    444                                 $plugins[$prefixe] = $infos;
    445                         }
    446                 }
    447         }
    448 
    449         migrateur_log("-> Plugins trouvés : " . implode(',', array_keys($plugins)));
    450 
    451         return $plugins;
    452 }
    453 
    454 
    455 
    456 /**
    457  * Ajouter des plugins actifs à la base en cours
    458  *
    459  * @note
    460  *   Il vaut mieux passer par SVP ou la fonction
    461  *   migrateur_activer_plugin_prefixes()
    462  *
    463  * @param array $plugins
    464  *     Couples (prefixe => infos)
    465 **/
    466 function migrateur_ajouter_plugins_actifs($plugins) {
    467         migrateur_log("Ajouter les plugins actifs : " . implode(',', array_keys($plugins)));
    468 
    469         $plugins_migrateurs = array();
    470 
    471         $plugins_actifs = sql_getfetsel('valeur', 'spip_meta', 'nom=' . sql_quote('plugin'));
    472         if ($plugins_actifs and $plugins_actifs = unserialize($plugins_actifs)) {
    473                 $plugins_actifs = array_merge($plugins_actifs, $plugins);
    474         } else {
    475                 $plugins_actifs = $plugins;
    476         }
    477 
    478         if (is_array($plugins_actifs)) {
    479                 ecrire_config('plugin', $plugins_actifs);
    480         }
    481 }
  • _plugins_/migrateur/trunk/migrateur/99_autres_exemples.php

    r85440 r85955  
    238238**/
    239239function migrateur_test_ssh_uptime() {
    240         $ssh = migrateur_source_ssh();
    241         if ($ssh) {
    242                 $cmd = $ssh->obtenir_commande_serveur();
     240        $source = migrateur_source();
     241        if ($source->ssh) {
     242                $cmd = $source->ssh->obtenir_commande_connexion();
    243243                if ($cmd) {
    244244                        $run = "$cmd uptime 2>&1";
  • _plugins_/migrateur/trunk/migrateur/mig_exporter_bdd.php

    r85410 r85955  
    88function migrateur_mig_exporter_bdd() {
    99
    10         $user = MIGRATEUR_SOURCE_SQL_USER;
    11         $pass = MIGRATEUR_SOURCE_SQL_PASS;
    12         $bdd  = MIGRATEUR_SOURCE_SQL_BDD;
    13         $dest = MIGRATEUR_DESTINATION_DIR . 'tmp/dump/';
    1410        sous_repertoire(_DIR_TMP . 'dump');
    1511
    16         $source_sql = MIGRATEUR_NOM_EXPORT_SQL;
     12        $source = migrateur_source();
     13        $dest   = migrateur_destination();
     14
     15        $sauvegarde = $dest->dir . 'tmp/dump/' . MIGRATEUR_NOM_EXPORT_SQL;
    1716
    1817        $output = "";
    19         exec("rm $dest$source_sql;");
    20         exec("rm $dest$source_sql.gz;");
     18        exec("rm $dir_dest$source_sql;");
     19        exec("rm $dir_dest$source_sql.gz;");
    2120
    22         // source et destination sur serveurs différents
    23         if ($ssh = migrateur_source_ssh()) {
     21        // source par ssh ?
     22        if ($ssh = $source->ssh) {
     23                $connexion = $ssh->obtenir_commande_connexion();
     24                $cmd = $ssh->obtenir_commande_serveur('mysqldump');
    2425
    25                 $ssh_cmd = $ssh->obtenir_commande_serveur();
    26                 $cmd = $ssh->obtenir_commande_serveur_distant('mysqldump');
    27 
    28                 if ($ssh_cmd and $cmd) {
    29                         $gzip = $ssh->obtenir_commande_serveur_distant('gzip');
    30                         $gunzip = migrateur_obtenir_commande_serveur('gunzip');
     26                if ($cmd) {
     27                        migrateur_log("Exécution de mysqldump distant…");
     28                        $gzip   = $ssh->obtenir_commande_serveur('gzip');
     29                        $gunzip = $ssh->obtenir_commande_serveur('gunzip');
    3130                        if ($gzip and $gunzip) {
    3231                                migrateur_log("Gzip présents : utilisation de compression");
    33                         }
    34                         migrateur_log("Exécution de mysqldump distant…");
    35                         if ($gzip) {
    36                                 $run = "$ssh_cmd \"$cmd -u $user --password=$pass $bdd | $gzip\" > $dest$source_sql.gz 2>&1";
     32                                $run = "$ssh_cmd \"$cmd -u {$source->sql->user} --password={$source->sql->pass} {$source->sql->bdd} | $gzip\" > $sauvegarde.gz 2>&1";
    3733                        } else {
    38                                 $run = "$ssh_cmd \"$cmd -u $user --password=$pass $bdd\" > $dest$source_sql 2>&1";
     34                                $run = "$ssh_cmd \"$cmd -u {$source->sql->user} --password={$source->sql->pass} {$source->sql->bdd}\" > $sauvegarde 2>&1";
    3935                        }
    4036                        #migrateur_log($run);
    4137                        exec($run, $output, $err);
    4238
    43                         if (!$err and $gzip) {
    44                                 exec("$gunzip $dest$source_sql.gz", $goutput, $gerr);
     39                        if (!$err and $gzip and $gunzip) {
     40                                exec("$gunzip $sauvegarde.gz", $goutput, $gerr);
    4541                                if ($gerr) {
    4642                                        migrateur_log("! Erreurs de décompression : $gerr");
     
    5450                                migrateur_log("! Erreurs survenues : $err");
    5551                        } else {
    56                                 $taille = filesize($dest . $source_sql);
     52                                $taille = filesize($sauvegarde);
    5753                                include_spip('inc/filtres');
    58                                 migrateur_log("> Fichier : " . $dest . $source_sql);
     54                                migrateur_log("> Fichier : " . $sauvegarde);
    5955                                migrateur_log("> Taille : " . taille_en_octets($taille));
    60                                 $firstline = shell_exec("head -n1 $dest$source_sql");
     56                                $firstline = shell_exec("head -n1 $sauvegarde");
    6157                                migrateur_log("> 1ere ligne : " . $firstline);
    6258                                if ( false === stripos($firstline, 'mysql') ) {
     
    6763                        migrateur_log("Connexion au serveur source impossible");
    6864                }
     65
    6966        }
     67
    7068
    7169        // source et destination sur le meme serveur
    7270        else {
    73                 $cmd = migrateur_obtenir_commande_serveur('mysqldump');
     71                $cmd = $source->commande('mysqldump');
    7472                if ($cmd) {
    7573                        migrateur_log("Exécution de mysqldump…");
    76                         exec("$cmd -u $user --password=$pass $bdd > $dest$source_sql 2>&1", $output, $err);
     74                        exec("$cmd -u {$source->sql->user} --password={$source->sql->pass} {$source->sql->bdd} > $sauvegarde 2>&1", $output, $err);
    7775                        if ($err) {
    7876                                migrateur_log("! Erreurs survenues : $err");
    7977                        } else {
    80                                 $taille = filesize($dest . $source_sql);
     78                                $taille = filesize($sauvegarde);
    8179                                include_spip('inc/filtres');
    82                                 migrateur_log("> Fichier : " . $dest . $source_sql);
     80                                migrateur_log("> Fichier : " . $sauvegarde);
    8381                                migrateur_log("> Taille : " . taille_en_octets($taille));
    8482                        }
  • _plugins_/migrateur/trunk/migrateur/mig_rsync_img.php

    r85414 r85955  
    77**/
    88function migrateur_mig_rsync_img() {
    9         $source     = MIGRATEUR_SOURCE_DIR  . 'IMG/';
    10         $dest       = MIGRATEUR_DESTINATION_DIR . 'IMG';
    11         $cmd = migrateur_obtenir_commande_serveur('rsync');
     9        $source = migrateur_source();
     10        $dest   = migrateur_destination();
     11
     12        $dir_source = $source->dir  . 'IMG/';
     13        $dir_dest   = $dest->dir . 'IMG';
     14
     15        $cmd = $dest->commande('rsync');
    1216        if ($cmd) {
     17                $cmd = "$cmd -a --delete --stats";
    1318
    1419                // source et destination sur serveurs différents
    15                 if ($ssh = migrateur_source_ssh()) {
    16                         exec("$cmd -a --no-o --no-p --delete --stats -e 'ssh -o StrictHostKeyChecking=no -p {$ssh->port}' {$ssh->user}@{$ssh->server}:$source $dest 2>&1", $output, $err);
    17                         migrateur_log(implode("\n", $output));
     20                if ($ssh = $source->ssh) {
     21                        $dir_source = $source->ssh->obtenir_rysnc_parametres() . $dir_source;
    1822                }
    1923
    20                 // source et destination sur le meme serveur
    21                 else {
    22                         exec("$cmd -a --delete --stats $source $dest 2>&1", $output, $err);
    23                         migrateur_log(implode("\n", $output));
    24                 }
     24                $cmd = "$cmd $dir_source $dir_dest 2>&1";
     25                #migrateur_log($cmd);
     26                exec($cmd, $output, $err);
     27                migrateur_log(implode("\n", $output));
     28
    2529        }
    2630}
  • _plugins_/migrateur/trunk/migrateur/mig_transferer_bdd.php

    r82844 r85955  
    8989function migrateur_copier_la_bdd($source_sql = '') {
    9090
    91         $dest       = MIGRATEUR_DESTINATION_DIR . 'tmp/dump/';
    92 
    93         if (!$source_sql) {
    94                 $source_sql = MIGRATEUR_NOM_EXPORT_SQL;
    95         }
    96 
    97         $user = MIGRATEUR_DESTINATION_SQL_USER;
    98         $pass = MIGRATEUR_DESTINATION_SQL_PASS;
    99         $bdd  = MIGRATEUR_DESTINATION_SQL_BDD;
    100 
     91        $dest = migrateur_destination();
     92        $sauvegarde = $dest->dir . 'tmp/dump/' . ($source_sql ? $source_sql : MIGRATEUR_NOM_EXPORT_SQL);
    10193
    10294        migrateur_log("Copie de la BDD par MySQL");
    103         //$mysql_cmd = "mysql --user=$user --password=$pass --default_character_set=utf8 $bdd < $dest$source_sql";
    104         $mysql_cmd = "mysql --user=$user --password=$pass $bdd < $dest$source_sql";
     95        //$mysql_cmd = "mysql --user={$dest->sql->user} --password={$dest->sql->pass} --default_character_set=utf8 {$dest->sql->bdd} < $sauvegarde";
     96        $mysql_cmd = "mysql --user={$dest->sql->user} --password={$dest->sql->pass} {$dest->sql->bdd} < $sauvegarde";
    10597
    10698        exec($mysql_cmd);
     
    108100
    109101
    110 
    111 /*
    112  * Vieux tests ou tentatives
    113  *
    114 
    115         # migrateur_log("Passer_webmestre");
    116         // on tente de passer webmestre
    117         #sql_alter("TABLE spip_auteurs ADD COLUMN webmestre varchar(3) DEFAULT 'non' NOT NULL AFTER statut");
    118         #migration_concurrences_webmestre();
    119 
    120 
    121         // Connecter l'auteur en cours
    122         migrateur_log("Reconnecter l'auteur en cours : " . $GLOBALS['visiteur_session']['id_auteur']);
    123         include_spip('inc/auth');
    124         $auteur = $GLOBALS['visiteur_session'];
    125         auth_loger($auteur);
    126 
    127 */
  • _plugins_/migrateur/trunk/paquet.xml

    r85415 r85955  
    22        prefix="migrateur"
    33        categorie="outil"
    4         version="2.4.1"
     4        version="2.5.0"
    55        etat="test"
    6         compatibilite="[3.0.5;3.0.*]"
     6        compatibilite="[3.0.5;3.1.*]"
    77        logo="prive/themes/spip/images/migrateur-64.png"
    88        documentation="http://contrib.spip.net/4477"
Note: See TracChangeset for help on using the changeset viewer.