[Sommaire] [Imprimer]

   1  <?php
   2  # ***** BEGIN LICENSE BLOCK *****
   3  # This file is part of DotClear.
   4  # Copyright (c) 2004-2005 Olivier Meunier and contributors. All rights
   5  # reserved.
   6  #
   7  # DotClear is free software; you can redistribute it and/or modify
   8  # it under the terms of the GNU General Public License as published by
   9  # the Free Software Foundation; either version 2 of the License, or
  10  # (at your option) any later version.
  11  #
  12  # DotClear is distributed in the hope that it will be useful,
  13  # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  # GNU General Public License for more details.
  16  #
  17  # You should have received a copy of the GNU General Public License
  18  # along with DotClear; if not, write to the Free Software
  19  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  #
  21  # ***** END LICENSE BLOCK *****
  22  /**
  23   * @class dbdump
  24   *
  25   */
  26  class dbdump {
  27      /**
  28      @function _getDCTablesList
  29  
  30      Création d'un tableau contenant la listes des tables DC à sauvegarder.
  31      Les tables 'log' et 'session' sont ignorées et les éventuelles tables
  32      de plugins ajoutées, si elles sont correctement préfixées.
  33  
  34      @return    array
  35      */
  36  	function _getDCTablesList()
  37      {
  38          global $con;
  39  
  40          // D'emblée, on précise les tables "natives" dans l'ordre d'importance
  41          // pour sécuriser au mieux la remontée.
  42          // NB : on ignore les tables 'log' et 'session'
  43          $dc_dump_tables =
  44              array(
  45                  DB_PREFIX.'user',
  46                  DB_PREFIX.'categorie',
  47                  DB_PREFIX.'post',
  48                  DB_PREFIX.'comment',
  49                  DB_PREFIX.'ping',
  50                  DB_PREFIX.'link'
  51              );
  52  
  53          // Récupération auprès de MySQL de la liste des tables préfixées
  54          // pour le DC courant
  55          $dc_tables = $con->select("SHOW TABLES LIKE '".DB_PREFIX."%'");
  56  
  57          // Maintenant on consolide le tout...
  58          while ($dc_tables->fetch()) {
  59              $dc_table = $dc_tables->f(0);
  60  
  61              // S'il s'agit de la table 'log' ou 'session', on écarte...
  62              if ($dc_table == DB_PREFIX.'log' ||
  63                  $dc_table == DB_PREFIX.'session') {
  64                  continue;
  65              }
  66  
  67              // On n'ajoute que les tables supplémentaires susceptibles
  68              // d'alimenter des plugins.
  69              if (in_array($dc_table, $dc_dump_tables)) {
  70                  continue;
  71              } else {
  72                  $dc_dump_tables[] = $dc_table;
  73              }
  74          }
  75  
  76          return($dc_dump_tables);
  77      }
  78  
  79  
  80      /**
  81       @function getDump
  82  
  83       Effectue un dump des tables DotClear sous forme d'un fichier SQL standard.
  84  
  85       L'export se compose pour chacune des tables :
  86          - d'une instruction conditionnelle DROP TABLE
  87          - de la clause complète CREATE TABLE (clés comprises)
  88          - des clauses INSERT nécessaires à la restauration des données.
  89  
  90       NB : Les noms des colonnes sont "backquotés".
  91  
  92       @return string La chaine représentant le dump.
  93       */
  94  	function getDump()
  95      {
  96          global $con;
  97  
  98          $dc_tables = dbdump::_getDCTablesList();
  99  
 100          // On précise à MySQL qu'il doit "quoter" les résultats des
 101          // requêtes SHOW CREATE TABLE qui vont suivre.
 102          $con->execute("SET SQL_QUOTE_SHOW_CREATE = 1");
 103  
 104          // Récupération de la version du serveur MySQL
 105          $rs = $con->select("SELECT REPLACE(VERSION(),'-log','')");
 106          $mysql_version = 'unknown';
 107          if ($rs) $mysql_version = $rs->f(0);
 108  
 109          // Une entête pour mettre quelques infos (in)utiles
 110          $dump_str =
 111              "#-------------------------------------------------------------------\n".
 112              "# Dump MySQL\n".
 113              "#\n".
 114              "# Blog     : ". dc_blog_name ."\n".
 115              "# DotClear : ". DC_VERSION ."\n".
 116              "# Serveur  : ". DB_HOST ." (MySQL v ". $mysql_version .")\n".
 117              "# Base     : ". DB_DBASE ."\n".
 118              "# Date     : ". date("d/m/Y H:i") ."\n".
 119              "#-------------------------------------------------------------------\n".
 120              "\n";
 121  
 122          // C'est parti !
 123          foreach ($dc_tables as $dc_table) {
 124              $rs = $con->select("SHOW CREATE TABLE $dc_table");
 125              while($rs->fetch()) {
 126  
 127                  // Dump de la clause CREATE TABLE
 128                  $dump_str .=
 129                      "#-------------------------------------------------------------------\n".
 130                      "# Structure de la table $dc_table\n".
 131                      "#-------------------------------------------------------------------\n".
 132                      "DROP TABLE IF EXISTS `$dc_table`;\n".
 133                      str_replace("\n","",$rs->f(1)).";".
 134                      "\n\n";
 135  
 136                  // Dump des clauses INSERT
 137                  $dump_str .=
 138                      "#-------------------------------------------------------------------\n".
 139                      "# Données de la table $dc_table\n".
 140                      "#-------------------------------------------------------------------\n";
 141                  $col_rs = $con->select("SELECT * FROM $dc_table");
 142                  while($col_rs->fetch()) {
 143                      $values = array();
 144                      for ($i = 0; $i < $col_rs->int_col_count; $i++) {
 145                          $values[] = $con->escapeStr($col_rs->f($i));
 146                      }
 147                      $dump_str .= "INSERT INTO `$dc_table` VALUES ( '". implode("', '",$values) ."' );\n";
 148                  }
 149                  $dump_str .= "\n";
 150              }
 151          }
 152          $dump_str .= "#-- EOF --\n";
 153  
 154          return($dump_str);
 155      }
 156  
 157  
 158      /**
 159       @function saveDump
 160  
 161       Enregistre un fichier de dump des tables DotClear.
 162       Avec les paramètres par défaut, un fichier gzippé dump-YYYYMMDD.sql.gz est
 163       créé dans le répertoire share/mysql/ de l'installation DotClear.
 164  
 165       @param    boolean    transmit    indicateur d'envoi du fichier de dump (false)
 166       @param string    path        le chemin d'enregistrement ('')
 167       @param string    name        le nom du fichier cible ('')
 168       @param boolean    compressed    indicateur de compression ou non (true)
 169  
 170       @return mixed Retourne une chaine représentant le nom du fichier dans lequel
 171                     le dump a été sauvegardé. Retourne un boolean à false en cas
 172                     de problème sinon.
 173  
 174       @see dbdump::getDump
 175       */
 176  	function saveDump($transmit = false, $path = '', $name = '', $compressed = true)
 177      {
 178          if ($compressed && !function_exists('gzencode')) {
 179              return(false);
 180          }
 181          if (!empty($path) && is_dir($path) && is_writable($path)) {
 182              $trg_path = $path;
 183          } else {
 184              $trg_path = DC_SHARE_DIR.'/mysql';
 185          }
 186          if (!empty($name)) {
 187              $trg_name = $name;
 188          } else {
 189              $trg_name = 'dbdump-'.date("Ymd").'.sql';
 190          }
 191          $dump = dbdump::getDump();
 192          if ($compressed) {
 193              $dump = gzencode($dump);
 194              $trg_name .= '.gz';
 195          }
 196          if ($transmit) {
 197              header('Content-Type: application/x-gzip');
 198              header('Content-Disposition: attachment; filename='.$trg_name);
 199              echo $dump;
 200              exit;
 201          } else {
 202              $trg_fullname = $trg_path.'/'.$trg_name;
 203              if ($fh = fopen($trg_fullname,"wb")) {
 204                  fwrite($fh, $dump);
 205                  fclose($fh);
 206              } else {
 207                  return(false);
 208              }
 209              return($trg_name);
 210          }
 211      }
 212  
 213  
 214      /**
 215       @function restoreDump
 216  
 217       Restaure des tables DotClear depuis un fichier de dump précédemment créé
 218       par l'opération de sauvegarde.
 219  
 220       @param string    src_file    le chemin du fichier de dump à restaurer
 221       @param boolean    compressed    indicateur de compression ou non (true)
 222  
 223       @return mixed Retourne une chaine indiquant que l'opération s'est correctement
 224                     déroulée. Retourne un boolean à false en cas de problème sinon.
 225  
 226       @see dbdump::saveDump
 227       */
 228  	function restoreDump($src_file, $compressed = true)
 229      {
 230          global $con;
 231  
 232          // Pour un fichier compressé, on crée un version décompressée
 233          // temporaire dans le répertoire share/mysql/
 234          $chrono_start = dbdump::_getChrono();
 235          if ($compressed) {
 236              if (!$fh = fopen($src_file, "rb")) {
 237                  return(false);
 238              }
 239              $tmp_dump = fread($fh, filesize($src_file));
 240              fclose($fh);
 241                if (!$dump = gzinflate(substr($tmp_dump, 10))) {
 242                    return(false);
 243                }
 244                unset($tmp_dump);
 245                $tmp_file = DC_SHARE_DIR.'/mysql/_'.basename($src_file);
 246              if (!$fh = fopen($tmp_file, "wb")) {
 247                  return(false);
 248              }
 249              fwrite($fh, $dump);
 250              fclose($fh);
 251              unlink($src_file);
 252              unset($dump);
 253              $src_file = $tmp_file;
 254           }
 255  
 256          // Parsing "simpliste" du fichier dump pour la remontée en base.
 257          // Seules les requêtes DROP TABLE, CREATE TABLE et INSERT seront
 258          // traitées.
 259          $scan = file($src_file);
 260          $token = $sql = '';
 261          foreach ($scan as $line) {
 262              $line = rtrim($line);
 263              if (empty($line) || strpos(ltrim($line), "#") === 0) continue;
 264              $token .= $line;
 265              if (preg_match("/^((DROP|CREATE) TABLE .*);$/", $token, $matches) ||
 266                  preg_match("/^(INSERT INTO (.*)'\s\));$/", $token, $matches)) {
 267                  $sql = $matches[1];
 268                  if (!empty($sql)) {
 269                      $res = $con->execute($sql);
 270                      if ($res === false) {
 271                          unlink($src_file);
 272                          return(false);
 273                      }
 274                  }
 275                  $token = $sql = '';
 276              }
 277          }
 278  
 279          unlink($src_file);
 280          $chrono_end = dbdump::_getChrono();
 281          buffer::str(sprintf("(%.2f sec.)",$chrono_end - $chrono_start));
 282          return(__('Dump has been restored'));
 283      }
 284  
 285  
 286      /**
 287      @function _getChrono
 288  
 289      @return    float
 290      */
 291  	function _getChrono()
 292      {
 293         list($usec, $sec) = explode(" ", microtime());
 294         return ((float)$usec + (float)$sec);
 295      }
 296  }
 297  ?>