www/ecrire/base/dump.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2019                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 /**
  14  * Fonctions de base pour la sauvegarde
  15  *
  16  * Boîte à outil commune, sans préjuger de la méthode de sauvegarde
  17  */
  18
  19 if (!defined('_ECRIRE_INC_VERSION')) {
  20         return;
  21 }
  22
  23 define('_VERSION_ARCHIVE', '1.3');
  24
  25 include_spip('base/serial');
  26 include_spip('base/auxiliaires');
  27 include_spip('public/interfaces'); // pour table_jointures
  28
  29 // NB: Ce fichier peut ajouter des tables (old-style)
  30 // donc il faut l'inclure "en globals"
  31 if ($f = find_in_path('mes_fonctions.php')) {
  32         global $dossier_squelettes;
  33         @include_once(_ROOT_CWD . $f);
  34 }
  35
  36 if (@is_readable(_CACHE_PLUGINS_FCT)) {
  37         // chargement optimise precompile
  38         include_once(_CACHE_PLUGINS_FCT);
  39 }
  40
  41 /**
  42  * Retourne un nom de meta pour une rubrique et l'auteur connecté.
  43  *
  44  * Ce nom servira pour le stockage dans un fichier temporaire des informations
  45  * sérialisées sur le statut de l'export.
  46  *
  47  * @param int $rub
  48  * @return string
  49  **/
  50 function base_dump_meta_name($rub) {
  51         return $meta = "status_dump_{$rub}_" . abs($GLOBALS['visiteur_session']['id_auteur']);
  52 }
  53
  54 /**
  55  * Crée un répertoire recevant la sauvegarde de la base de données
  56  * et retourne son chemin.
  57  *
  58  * @note
  59  *   Utilisé uniquement dans l'ancienne sauvegarde XML (plugin dump_xml)
  60  *   À supprimer ?
  61  *
  62  * @param string $meta
  63  * @return string
  64  **/
  65 function base_dump_dir($meta) {
  66         include_spip('inc/documents');
  67         // determine upload va aussi initialiser l'index "restreint"
  68         $maindir = determine_upload();
  69         if (!$GLOBALS['visiteur_session']['restreint']) {
  70                 $maindir = _DIR_DUMP;
  71         }
  72         $dir = sous_repertoire($maindir, $meta);
  73
  74         return $dir;
  75 }
  76
  77 /**
  78  * Lister toutes les tables d'un serveur
  79  * en excluant eventuellement une liste fournie
  80  *
  81  * @param string $serveur
  82  * @param array $tables
  83  * @param array $exclude
  84  * @param bool $affiche_vrai_prefixe
  85  * @return array
  86  */
  87 function base_lister_toutes_tables(
  88         $serveur = '',
  89         $tables = array(),
  90         $exclude = array(),
  91         $affiche_vrai_prefixe = false
  92 ) {
  93         spip_connect($serveur);
  94         $connexion = $GLOBALS['connexions'][$serveur ? $serveur : 0];
  95         $prefixe = $connexion['prefixe'];
  96
  97         $p = '/^' . $prefixe . '/';
  98         $res = $tables;
  99         foreach (sql_alltable(null, $serveur) as $t) {
 100                 if (preg_match($p, $t)) {
 101                         $t1 = preg_replace($p, 'spip', $t);
 102                         if (!in_array($t1, $tables) and !in_array($t1, $exclude)) {
 103                                 $res[] = ($affiche_vrai_prefixe ? $t : $t1);
 104                         }
 105                 }
 106         }
 107         sort($res);
 108
 109         return $res;
 110 }
 111
 112 /**
 113  * Retrouver le prefixe des tables
 114  *
 115  * @param string $serveur
 116  * @return string
 117  */
 118 function base_prefixe_tables($serveur = '') {
 119         spip_connect($serveur);
 120         $connexion = $GLOBALS['connexions'][$serveur ? $serveur : 0];
 121         $prefixe = $connexion['prefixe'];
 122
 123         return $prefixe;
 124 }
 125
 126
 127 /**
 128  * Fabrique la liste a cocher des tables a traiter (copie, delete, sauvegarde)
 129  *
 130  * @param string $name
 131  * @param array $tables
 132  * @param array $exclude
 133  * @param array|null $post
 134  * @param string $serveur
 135  * @return array
 136  */
 137 function base_saisie_tables($name, $tables, $exclude = array(), $post = null, $serveur = '') {
 138         include_spip('inc/filtres');
 139         $res = array();
 140         foreach ($tables as $k => $t) {
 141                 // par defaut tout est coche sauf les tables dans $exclude
 142                 if (is_null($post)) {
 143                         $check = (in_array($t, $exclude) ? false : true);
 144                 } // mais si on a poste une selection, la reprendre
 145                 else {
 146                         $check = in_array($t, $post);
 147                 }
 148
 149                 $res[$k] = "<input type='checkbox' value='$t' name='$name"
 150                         . "[]' id='$name$k'"
 151                         . ($check ? " checked='checked'" : '')
 152                         . "/>\n"
 153                         . "<label for='$name$k'>$t</label>"
 154                         . " ("
 155                         . sinon(singulier_ou_pluriel(sql_countsel($t, '', '', '', $serveur), 'dump:une_donnee', 'dump:nb_donnees'),
 156                                 _T('dump:aucune_donnee'))
 157                         . ")";
 158         }
 159
 160         return $res;
 161 }
 162
 163
 164 /**
 165  * Lister les tables non exportables par defaut
 166  * (liste completable par le pipeline lister_tables_noexport
 167  *
 168  * @staticvar array $EXPORT_tables_noexport
 169  * @return array
 170  */
 171 function lister_tables_noexport() {
 172         // par defaut tout est exporte sauf les tables ci-dessous
 173         static $EXPORT_tables_noexport = null;
 174         if (!is_null($EXPORT_tables_noexport)) {
 175                 return $EXPORT_tables_noexport;
 176         }
 177
 178         $EXPORT_tables_noexport = array(
 179                 'spip_caches', // plugin invalideur
 180                 'spip_resultats', // resultats de recherche ... c'est un cache !
 181                 'spip_test', // c'est un test !
 182                 #'spip_referers',
 183                 #'spip_referers_articles',
 184                 #'spip_visites',
 185                 #'spip_visites_articles',
 186                 #'spip_versions',
 187                 #'spip_versions_fragments'
 188         );
 189
 190         $EXPORT_tables_noexport = pipeline('lister_tables_noexport', $EXPORT_tables_noexport);
 191
 192         return $EXPORT_tables_noexport;
 193 }
 194
 195 /**
 196  * Lister les tables non importables par defaut
 197  * (liste completable par le pipeline lister_tables_noimport
 198  *
 199  * @staticvar array $IMPORT_tables_noimport
 200  * @return array
 201  */
 202 function lister_tables_noimport() {
 203         static $IMPORT_tables_noimport = null;
 204         if (!is_null($IMPORT_tables_noimport)) {
 205                 return $IMPORT_tables_noimport;
 206         }
 207
 208         $IMPORT_tables_noimport = array();
 209         // par defaut tout est importe sauf les tables ci-dessous
 210         // possibiliter de definir cela tables via la meta
 211         // compatibilite
 212         if (isset($GLOBALS['meta']['IMPORT_tables_noimport'])) {
 213                 $IMPORT_tables_noimport = unserialize($GLOBALS['meta']['IMPORT_tables_noimport']);
 214                 if (!is_array($IMPORT_tables_noimport)) {
 215                         include_spip('inc/meta');
 216                         effacer_meta('IMPORT_tables_noimport');
 217                 }
 218         }
 219         $IMPORT_tables_noimport = pipeline('lister_tables_noimport', $IMPORT_tables_noimport);
 220
 221         return $IMPORT_tables_noimport;
 222 }
 223
 224
 225 /**
 226  * Lister les tables a ne pas effacer
 227  * (liste completable par le pipeline lister_tables_noerase
 228  *
 229  * @staticvar array $IMPORT_tables_noerase
 230  * @return array
 231  */
 232 function lister_tables_noerase() {
 233         static $IMPORT_tables_noerase = null;
 234         if (!is_null($IMPORT_tables_noerase)) {
 235                 return $IMPORT_tables_noerase;
 236         }
 237
 238         $IMPORT_tables_noerase = array(
 239                 'spip_meta',
 240                 // par defaut on ne vide pas les stats, car elles ne figurent pas dans les dump
 241                 // et le cas echeant, un bouton dans l'admin permet de les vider a la main...
 242                 'spip_referers',
 243                 'spip_referers_articles',
 244                 'spip_visites',
 245                 'spip_visites_articles'
 246         );
 247         $IMPORT_tables_noerase = pipeline('lister_tables_noerase', $IMPORT_tables_noerase);
 248
 249         return $IMPORT_tables_noerase;
 250 }
 251
 252
 253 /**
 254  * construction de la liste des tables pour le dump :
 255  * toutes les tables principales
 256  * + toutes les tables auxiliaires hors relations
 257  * + les tables relations dont les deux tables liees sont dans la liste
 258  *
 259  * @param array $exclude_tables
 260  * @return array
 261  */
 262 function base_liste_table_for_dump($exclude_tables = array()) {
 263         $tables_for_dump = array();
 264         $tables_pointees = array();
 265         $tables = array();
 266         $tables_principales = $GLOBALS['tables_principales'];
 267         $tables_auxiliaires = $GLOBALS['tables_auxiliaires'];
 268         $tables_jointures = $GLOBALS['tables_jointures'];
 269
 270         if (include_spip('base/objets')
 271                 and function_exists('lister_tables_objets_sql')
 272         ) {
 273                 $tables = lister_tables_objets_sql();
 274                 foreach ($tables as $t => $infos) {
 275                         if ($infos['principale'] and !isset($tables_principales[$t])) {
 276                                 $tables_principales[$t] = true;
 277                         }
 278                         if (!$infos['principale'] and !isset($tables_auxiliaires[$t])) {
 279                                 $tables_auxiliaires[$t] = true;
 280                         }
 281                         if (count($infos['tables_jointures'])) {
 282                                 $tables_jointures[$t] = array_merge(isset($tables_jointures[$t]) ? $tables_jointures[$t] : array(),
 283                                         $infos['tables_jointures']);
 284                         }
 285                 }
 286         }
 287
 288         // on construit un index des tables de liens
 289         // pour les ajouter SI les deux tables qu'ils connectent sont sauvegardees
 290         $tables_for_link = array();
 291         foreach ($tables_jointures as $table => $liste_relations) {
 292                 if (is_array($liste_relations)) {
 293                         $nom = $table;
 294                         if (!isset($tables_auxiliaires[$nom]) && !isset($tables_principales[$nom])) {
 295                                 $nom = "spip_$table";
 296                         }
 297                         if (isset($tables_auxiliaires[$nom]) || isset($tables_principales[$nom])) {
 298                                 foreach ($liste_relations as $link_table) {
 299                                         if (isset($tables_auxiliaires[$link_table])/*||isset($tables_principales[$link_table])*/) {
 300                                                 $tables_for_link[$link_table][] = $nom;
 301                                         } else {
 302                                                 if (isset($tables_auxiliaires["spip_$link_table"])/*||isset($tables_principales["spip_$link_table"])*/) {
 303                                                         $tables_for_link["spip_$link_table"][] = $nom;
 304                                                 }
 305                                         }
 306                                 }
 307                         }
 308                 }
 309         }
 310
 311         $liste_tables = array_merge(array_keys($tables_principales), array_keys($tables_auxiliaires), array_keys($tables));
 312         foreach ($liste_tables as $table) {
 313                 //              $name = preg_replace("{^spip_}","",$table);
 314                 if (!isset($tables_pointees[$table])
 315                         && !in_array($table, $exclude_tables)
 316                         && !isset($tables_for_link[$table])
 317                 ) {
 318                         $tables_for_dump[] = $table;
 319                         $tables_pointees[$table] = 1;
 320                 }
 321         }
 322         foreach ($tables_for_link as $link_table => $liste) {
 323                 $connecte = true;
 324                 foreach ($liste as $connect_table) {
 325                         if (!in_array($connect_table, $tables_for_dump)) {
 326                                 $connecte = false;
 327                         }
 328                 }
 329                 if ($connecte)
 330                         # on ajoute les liaisons en premier
 331                         # si une restauration est interrompue,
 332                         # cela se verra mieux si il manque des objets
 333                         # que des liens
 334                 {
 335                         array_unshift($tables_for_dump, $link_table);
 336                 }
 337         }
 338
 339         return array($tables_for_dump, $tables_for_link);
 340 }
 341
 342 /**
 343  * Vider les tables de la base de destination
 344  * pour la copie dans une base
 345  *
 346  * peut etre utilise pour l'import depuis xml,
 347  * ou la copie de base a base (mysql<->sqlite par exemple)
 348  *
 349  * @param array $tables
 350  * @param array $exclure_tables
 351  * @param string $serveur
 352  */
 353 function base_vider_tables_destination_copie($tables, $exclure_tables = array(), $serveur = '') {
 354         $trouver_table = charger_fonction('trouver_table', 'base');
 355
 356         spip_log('Vider ' . count($tables) . " tables sur serveur '$serveur' : " . join(', ', $tables),
 357                 'base.' . _LOG_INFO_IMPORTANTE);
 358         foreach ($tables as $table) {
 359                 if (!in_array($table, $exclure_tables)) {
 360                         // sur le serveur principal, il ne faut pas supprimer l'auteur loge !
 361                         if (($table != 'spip_auteurs') or $serveur != '') {
 362                                 // regarder si il y a au moins un champ impt='non'
 363                                 $desc = $trouver_table($table, $serveur);
 364                                 if (isset($desc['field']['impt'])) {
 365                                         sql_delete($table, "impt='oui'", $serveur);
 366                                 } else {
 367                                         sql_delete($table, "", $serveur);
 368                                 }
 369                         }
 370                 }
 371         }
 372
 373         // sur le serveur principal, il ne faut pas supprimer l'auteur loge !
 374         // Bidouille pour garder l'acces admin actuel pendant toute la restauration
 375         if ($serveur == ''
 376                 and in_array('spip_auteurs', $tables)
 377                 and !in_array('spip_auteurs', $exclure_tables)
 378         ) {
 379                 base_conserver_copieur(true, $serveur);
 380                 sql_delete("spip_auteurs", "id_auteur>0", $serveur);
 381         }
 382 }
 383
 384 /**
 385  * Conserver le copieur si besoin
 386  *
 387  * @param bool $move
 388  * @param string $serveur
 389  * @return void
 390  */
 391 function base_conserver_copieur($move = true, $serveur = '') {
 392         // s'asurer qu'on a pas deja fait la manip !
 393         if ($GLOBALS['visiteur_session']['id_auteur'] > 0 and sql_countsel("spip_auteurs", "id_auteur>0")) {
 394                 spip_log('Conserver copieur dans id_auteur=' . $GLOBALS['visiteur_session']['id_auteur'] . " pour le serveur '$serveur'",
 395                         'dump.' . _LOG_INFO_IMPORTANTE);
 396                 sql_delete("spip_auteurs", "id_auteur<0", $serveur);
 397                 if ($move) {
 398                         sql_updateq('spip_auteurs', array('id_auteur' => -$GLOBALS['visiteur_session']['id_auteur']),
 399                                 "id_auteur=" . intval($GLOBALS['visiteur_session']['id_auteur']), array(), $serveur);
 400                 } else {
 401                         $row = sql_fetsel('*', 'spip_auteurs', 'id_auteur=' . $GLOBALS['visiteur_session']['id_auteur'], '', '', '', '',
 402                                 $serveur);
 403                         $row['id_auteur'] = -$GLOBALS['visiteur_session']['id_auteur'];
 404                         sql_insertq('spip_auteurs', $row, array(), $serveur);
 405                 }
 406         }
 407 }
 408
 409 /**
 410  * Effacement de la bidouille ci-dessus
 411  * Toutefois si la table des auteurs ne contient plus qu'elle
 412  * c'est que la copie etait incomplete et on restaure le compte
 413  * pour garder la connection au site
 414  *
 415  * (mais il doit pas etre bien beau
 416  * et ca ne marche que si l'id_auteur est sur moins de 3 chiffres)
 417  *
 418  * @param string $serveur
 419  */
 420 function base_detruire_copieur_si_besoin($serveur = '') {
 421         // rien a faire si ce n'est pas le serveur principal !
 422         if ($serveur == '') {
 423                 if (sql_countsel("spip_auteurs", "id_auteur>0")) {
 424                         spip_log("Detruire copieur id_auteur<0 pour le serveur '$serveur'", 'dump.' . _LOG_INFO_IMPORTANTE);
 425                         sql_delete("spip_auteurs", "id_auteur<0", $serveur);
 426                 } else {
 427                         spip_log("Restaurer copieur id_auteur<0 pour le serveur '$serveur' (aucun autre auteur en base)",
 428                                 'dump.' . _LOG_INFO_IMPORTANTE);
 429                         sql_update('spip_auteurs', array('id_auteur' => '-id_auteur'), "id_auteur<0");
 430                 }
 431         } else {
 432                 spip_log("Pas de destruction copieur sur serveur '$serveur'", 'dump.' . _LOG_INFO_IMPORTANTE);
 433         }
 434 }
 435
 436 /**
 437  * Preparer la table dans la base de destination :
 438  * la droper si elle existe (sauf si auteurs ou meta sur le serveur principal)
 439  * la creer si necessaire, ou ajouter simplement les champs manquants
 440  *
 441  * @param string $table
 442  * @param array $desc
 443  * @param string $serveur_dest
 444  * @param bool $init
 445  * @return array
 446  */
 447 function base_preparer_table_dest($table, $desc, $serveur_dest, $init = false) {
 448         $upgrade = false;
 449         // si la table existe et qu'on est a l'init, la dropper
 450         if ($desc_dest = sql_showtable($table, true, $serveur_dest) and $init) {
 451                 if ($serveur_dest == '' and in_array($table, array('spip_meta', 'spip_auteurs'))) {
 452                         // ne pas dropper auteurs et meta sur le serveur principal
 453                         // faire un simple upgrade a la place
 454                         // pour ajouter les champs manquants
 455                         $upgrade = true;
 456                         // coherence avec le drop sur les autres tables
 457                         base_vider_tables_destination_copie(array($table), array(), $serveur_dest);
 458                         if ($table == 'spip_meta') {
 459                                 // virer les version base qui vont venir avec l'import
 460                                 sql_delete($table, "nom like '%_base_version'", $serveur_dest);
 461                                 // hum casse la base si pas version_installee a l'import ...
 462                                 sql_delete($table, "nom='version_installee'", $serveur_dest);
 463                         }
 464                 } else {
 465                         sql_drop_table($table, '', $serveur_dest);
 466                         spip_log("drop table '$table' sur serveur '$serveur_dest'", 'dump.' . _LOG_INFO_IMPORTANTE);
 467                 }
 468                 $desc_dest = false;
 469         }
 470         // si la table n'existe pas dans la destination, la creer a l'identique !
 471         if (!$desc_dest) {
 472                 spip_log("creation '$table' sur serveur '$serveur_dest'", 'dump.' . _LOG_INFO_IMPORTANTE);
 473                 include_spip('base/create');
 474                 creer_ou_upgrader_table($table, $desc, 'auto', $upgrade, $serveur_dest);
 475                 $desc_dest = sql_showtable($table, true, $serveur_dest);
 476         }
 477         if (!$desc_dest) {
 478                 spip_log("Erreur creation '$table' sur serveur '$serveur_dest'" . var_export($desc, 1), 'dump.' . _LOG_ERREUR);
 479         }
 480
 481         return $desc_dest;
 482 }
 483
 484 /**
 485  * Copier de base a base
 486  *
 487  * @param string $status_file
 488  *   nom avec chemin complet du fichier ou est stocke le status courant
 489  * @param array $tables
 490  *   liste des tables a copier
 491  * @param string $serveur_source
 492  * @param string $serveur_dest
 493  * @param array $options
 494  *   parametres optionnels sous forme de tableau :
 495  *   param string $callback_progression
 496  *     fonction a appeler pour afficher la progression, avec les arguments (compteur,total,table)
 497  *   param int $max_time
 498  *     limite de temps au dela de laquelle sortir de la fonction proprement (de la forme time()+15)
 499  *   param bool $drop_source
 500  *     vider les tables sources apres copie
 501  *   param array $no_erase_dest
 502  *     liste des tables a ne pas vider systematiquement (ne seront videes que si existent dans la base source)
 503  *   param array $where
 504  *     liste optionnelle de condition where de selection des donnees pour chaque table
 505  *   param string $racine_fonctions_dest
 506  *     racine utilisee pour charger_fonction() des operations elementaires sur la base de destination.
 507  *     Permet de deleguer vers une autre voie de communication.
 508  *     Par defaut on utilise 'base', ce qui route vers les fonctions de ce fichier. Concerne :
 509  *     - vider_tables_destination_copie
 510  *     - preparer_table_dest
 511  *     - detruire_copieur_si_besoin
 512  *     - inserer_copie
 513  *   param array $fonction_base_inserer
 514  *     fonction d'insertion en base. Par defaut "inserer_copie" qui fait un insertq a l'identique.
 515  *     Attention, la fonction appelee est prefixee par $racine_fonctions_dest via un charger_fonction()
 516  *     Peut etre personalisee pour filtrer, renumeroter....
 517  *   param array $desc_tables_dest
 518  *     description des tables de destination a utiliser de preference a la description de la table source
 519  *   param int data_pool
 520  *     nombre de ko de donnees a envoyer d'un coup en insertion dans la table cible (par defaut 1)
 521  *     permet des envois groupes pour plus de rapidite, notamment si l'insertion est distante
 522  *
 523  * @return bool
 524  */
 525 function base_copier_tables($status_file, $tables, $serveur_source, $serveur_dest, $options = array()) {
 526
 527         $callback_progression = isset($options['callback_progression']) ? $options['callback_progression'] : '';
 528         $max_time = isset($options['max_time']) ? $options['max_time'] : 0;
 529         $drop_source = isset($options['drop_source']) ? $options['drop_source'] : false;
 530         $no_erase_dest = isset($options['no_erase_dest']) ? $options['no_erase_dest'] : array();
 531         $where = isset($options['where']) ? $options['where'] : array();
 532         $fonction_base_inserer = isset($options['fonction_base_inserer']) ? $options['fonction_base_inserer'] : 'inserer_copie';
 533         $desc_tables_dest = isset($options['desc_tables_dest']) ? $options['desc_tables_dest'] : array();
 534         $racine_fonctions = (isset($options['racine_fonctions_dest']) ? $options['racine_fonctions_dest'] : 'base');
 535         $data_pool = (isset($options['data_pool']) ? $options['data_pool'] : 50 * 1024);
 536
 537         spip_log("Copier " . count($tables) . " tables de '$serveur_source' vers '$serveur_dest'",
 538                 'dump.' . _LOG_INFO_IMPORTANTE);
 539
 540         if (!$inserer_copie = charger_fonction($fonction_base_inserer, $racine_fonctions, true)) {
 541                 spip_log("Fonction '{$racine_fonctions}_$fonction_base_inserer' inconnue. Abandon", 'dump.' . _LOG_INFO_IMPORTANTE);
 542
 543                 return true; // echec mais on a fini, donc true
 544         }
 545         if (!$preparer_table_dest = charger_fonction('preparer_table_dest', $racine_fonctions, true)) {
 546                 spip_log("Fonction '{$racine_fonctions}_$preparer_table_dest' inconnue. Abandon", 'dump.' . _LOG_INFO_IMPORTANTE);
 547
 548                 return true; // echec mais on a fini, donc true
 549         }
 550
 551         if (!lire_fichier($status_file, $status)
 552                 or !$status = unserialize($status)
 553         ) {
 554                 $status = array();
 555         }
 556         $status['etape'] = 'basecopie';
 557
 558         // puis relister les tables a importer
 559         // et les vider si besoin, au moment du premier passage ici
 560         $initialisation_copie = (!isset($status["dump_status_copie"])) ? 0 : $status["dump_status_copie"];
 561
 562         // si init pas encore faite, vider les tables du serveur destination
 563         if (!$initialisation_copie) {
 564                 if (!$vider_tables_destination_copie = charger_fonction('vider_tables_destination_copie', $racine_fonctions,
 565                         true)
 566                 ) {
 567                         spip_log("Fonction '{$racine_fonctions}_vider_tables_destination_copie' inconnue. Abandon",
 568                                 'dump.' . _LOG_INFO_IMPORTANTE);
 569
 570                         return true; // echec mais on a fini, donc true
 571                 }
 572                 $vider_tables_destination_copie($tables, $no_erase_dest, $serveur_dest);
 573                 $status["dump_status_copie"] = 'ok';
 574                 ecrire_fichier($status_file, serialize($status));
 575         }
 576
 577         // les tables auteurs et meta doivent etre copiees en dernier !
 578         if (in_array('spip_auteurs', $tables)) {
 579                 $tables = array_diff($tables, array('spip_auteurs'));
 580                 $tables[] = 'spip_auteurs';
 581         }
 582         if (in_array('spip_meta', $tables)) {
 583                 $tables = array_diff($tables, array('spip_meta'));
 584                 $tables[] = 'spip_meta';
 585         }
 586         spip_log("Tables a copier :" . implode(", ", $tables), 'dump.' . _LOG_INFO);
 587
 588         $trouver_table = charger_fonction('trouver_table', 'base');
 589
 590         foreach ($tables as $table) {
 591                 // si table commence par spip_ c'est une table SPIP, renommer le prefixe si besoin
 592                 // sinon chercher la vraie table
 593                 $desc_source = false;
 594                 if (strncmp($table, "spip_", 5) == 0) {
 595                         $desc_source = $trouver_table(preg_replace(",^spip_,", "", $table), $serveur_source, true);
 596                 }
 597                 if (!$desc_source or !isset($desc_source['exist']) or !$desc_source['exist']) {
 598                         $desc_source = $trouver_table($table, $serveur_source, false);
 599                 }
 600
 601                 // verifier que la table est presente dans la base source
 602                 if ($desc_source) {
 603                         // $status['tables_copiees'][$table] contient l'avancement
 604                         // de la copie pour la $table : 0 a N et -N quand elle est finie (-1 si vide et finie...)
 605                         if (!isset($status['tables_copiees'][$table])) {
 606                                 $status['tables_copiees'][$table] = 0;
 607                         }
 608
 609                         if (is_numeric($status['tables_copiees'][$table])
 610                                 and $status['tables_copiees'][$table] >= 0
 611                                 and $desc_dest = $preparer_table_dest(
 612                                         $table,
 613                                         isset($desc_tables_dest[$table]) ? $desc_tables_dest[$table] : $desc_source,
 614                                         $serveur_dest,
 615                                         $status['tables_copiees'][$table] == 0)
 616                         ) {
 617                                 if ($callback_progression) {
 618                                         $callback_progression($status['tables_copiees'][$table], 0, $table);
 619                                 }
 620                                 while (true) {
 621                                         $n = intval($status['tables_copiees'][$table]);
 622                                         // on copie par lot de 400
 623                                         $res = sql_select('*', $table, isset($where[$table]) ? $where[$table] : '', '', '', "$n,400", '',
 624                                                 $serveur_source);
 625                                         while ($row = sql_fetch($res, $serveur_source)) {
 626                                                 $rows = array($row);
 627                                                 // lire un groupe de donnees si demande en option
 628                                                 // (permet un envoi par lot vers la destination)
 629                                                 if ($data_pool > 0) {
 630                                                         $s = strlen(serialize($row));
 631                                                         while ($s < $data_pool and $row = sql_fetch($res, $serveur_source)) {
 632                                                                 $s += strlen(serialize($row));
 633                                                                 $rows[] = $row;
 634                                                         }
 635                                                 }
 636                                                 // si l'enregistrement est deja en base, ca fera un echec ou un doublon
 637                                                 // mais si ca renvoie false c'est une erreur fatale => abandon
 638                                                 if ($inserer_copie($table, $rows, $desc_dest, $serveur_dest) === false) {
 639                                                         // forcer la sortie, charge a l'appelant de gerer l'echec
 640                                                         spip_log("Erreur fatale dans $inserer_copie table $table", "dump" . _LOG_ERREUR);
 641                                                         $status['errors'][] = "Erreur fatale  lors de la copie de la table $table";
 642                                                         ecrire_fichier($status_file, serialize($status));
 643
 644                                                         // copie finie
 645                                                         return true;
 646                                                 }
 647                                                 $status['tables_copiees'][$table] += count($rows);
 648                                                 if ($max_time and time() > $max_time) {
 649                                                         break;
 650                                                 }
 651                                         }
 652                                         if ($n == $status['tables_copiees'][$table]) {
 653                                                 break;
 654                                         }
 655                                         spip_log("recopie $table " . $status['tables_copiees'][$table], 'dump.' . _LOG_INFO_IMPORTANTE);
 656                                         if ($callback_progression) {
 657                                                 $callback_progression($status['tables_copiees'][$table], 0, $table);
 658                                         }
 659                                         ecrire_fichier($status_file, serialize($status));
 660                                         if ($max_time and time() > $max_time) {
 661                                                 return false;
 662                                         } // on a pas fini, mais le temps imparti est ecoule
 663                                 }
 664                                 if ($drop_source) {
 665                                         sql_drop_table($table, '', $serveur_source);
 666                                         spip_log("drop $table sur serveur source '$serveur_source'", 'dump.' . _LOG_INFO_IMPORTANTE);
 667                                 }
 668                                 $status['tables_copiees'][$table] = ($status['tables_copiees'][$table] ? -$status['tables_copiees'][$table] : "zero");
 669                                 ecrire_fichier($status_file, serialize($status));
 670                                 spip_log("tables_recopiees " . implode(',', array_keys($status['tables_copiees'])), 'dump.' . _LOG_INFO);
 671                                 if ($callback_progression) {
 672                                         $callback_progression($status['tables_copiees'][$table], $status['tables_copiees'][$table], $table);
 673                                 }
 674                         } else {
 675                                 if ($status['tables_copiees'][$table] < 0) {
 676                                         spip_log("Table $table deja copiee : " . $status['tables_copiees'][$table], "dump." . _LOG_INFO);
 677                                 }
 678                                 if ($callback_progression) {
 679                                         $callback_progression(0, $status['tables_copiees'][$table],
 680                                                 "$table" . ((is_numeric($status['tables_copiees'][$table]) and $status['tables_copiees'][$table] >= 0) ? "[Echec]" : ""));
 681                                 }
 682                         }
 683                 } else {
 684                         $status['errors'][] = "Impossible de lire la description de la table $table";
 685                         ecrire_fichier($status_file, serialize($status));
 686                         spip_log("Impossible de lire la description de la table $table", "dump." . _LOG_ERREUR);
 687                 }
 688         }
 689
 690         // si le nombre de tables envoyees n'est pas egal au nombre de tables demandees
 691         // abandonner
 692         if (count($status['tables_copiees']) < count($tables)) {
 693                 spip_log("Nombre de tables copiees incorrect : " . count($status['tables_copiees']) . "/" . count($tables),
 694                         "dump." . _LOG_ERREUR);
 695                 $status['errors'][] = "Nombre de tables copiees incorrect : " . count($status['tables_copiees']) . "/" . count($tables);
 696                 ecrire_fichier($status_file, serialize($status));
 697         }
 698
 699         if ($detruire_copieur_si_besoin = charger_fonction('detruire_copieur_si_besoin', $racine_fonctions, true)) {
 700                 $detruire_copieur_si_besoin($serveur_dest);
 701         } else {
 702                 spip_log("Fonction '{$racine_fonctions}_detruire_copieur_si_besoin' inconnue.", 'dump.' . _LOG_INFO_IMPORTANTE);
 703         }
 704
 705         // OK, copie complete
 706         return true;
 707 }
 708
 709 /**
 710  * fonction d'insertion en base lors de la copie de base a base
 711  *
 712  * @param string $table
 713  * @param array $rows
 714  * @param array $desc_dest
 715  * @param string $serveur_dest
 716  * @return int/bool
 717  */
 718 function base_inserer_copie($table, $rows, $desc_dest, $serveur_dest) {
 719
 720         // verifier le nombre d'insertion
 721         $nb1 = sql_countsel($table, '', '', '', $serveur_dest);
 722         // si l'enregistrement est deja en base, ca fera un echec ou un doublon
 723         $r = sql_insertq_multi($table, $rows, $desc_dest, $serveur_dest);
 724         $nb = sql_countsel($table, '', '', '', $serveur_dest);
 725         if ($nb - $nb1 < count($rows)) {
 726                 spip_log("base_inserer_copie : " . ($nb - $nb1) . " insertions au lieu de " . count($rows) . ". On retente 1 par 1",
 727                         "dump" . _LOG_INFO_IMPORTANTE);
 728                 foreach ($rows as $row) {
 729                         // si l'enregistrement est deja en base, ca fera un echec ou un doublon
 730                         $r = sql_insertq($table, $row, $desc_dest, $serveur_dest);
 731                 }
 732                 // on reverifie le total
 733                 $r = 0;
 734                 $nb = sql_countsel($table, '', '', '', $serveur_dest);
 735                 if ($nb - $nb1 < count($rows)) {
 736                         spip_log("base_inserer_copie : " . ($nb - $nb1) . " insertions au lieu de " . count($rows) . " apres insertion 1 par 1",
 737                                 "dump" . _LOG_ERREUR);
 738                         $r = false;
 739                 }
 740         }
 741
 742         return $r;
 743 }