source: spip-zone/_core_/plugins/dump/inc/dump.php @ 93639

Last change on this file since 93639 was 93639, checked in by marcimat@…, 5 years ago

Meilleure compatibilité avec PSR-2 et nos règles d'écriture, en appliquant
différents fix avec php-cs-fixers. Fixers appliqués ici :

'encoding', utf8
'eof_ending',
un saut de ligne en fin de fichier
'elseif', elseif plutôt que else if
'function_call_space',
espaces sur fonctions
'function_declaration', espaces sur fonctions
'function_typehint_space',
espaces sur fonctions
'linefeed', sauts de ligne \n uniquement
'lowercase_constants',
true, false, null en munuscule
'lowercase_keywords', mots clés PHP en lowercase
'method_argument_space',
espaces sur appels de fonctions
'multiple_use', use unique sur fonctions anonymes
'newline_after_open_tag',
ouverture de php… et c'est tout sur cette ligne
'operators_spaces', espaces de part et d'autres des opérateurs binaires
'parenthesis',
pas d'espace juste après parenthèse ouvrante, ou avant parenthèse fermante
'php_closing_tag', pas de fermeture de php
'short_tag',
tag PHP corrects
'trailing_spaces', pas d'espace qui traîne en fin de ligne
'visibility',
déclarer 'public / private / protected' sur les méthodes

File size: 10.3 KB
Line 
1<?php
2
3/***************************************************************************\
4 *  SPIP, Systeme de publication pour l'internet                           *
5 *                                                                         *
6 *  Copyright (c) 2001-2015                                                *
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 * API permettant la manipulation des sauvegardes
15 *
16 * @package SPIP\Dump\API
17 */
18
19if (!defined("_ECRIRE_INC_VERSION")) {
20        return;
21}
22
23
24/**
25 * Répertoire de sauvegarde
26 *
27 * Crée et retourne le chemin du répertoire de sauvegarde
28 *
29 * @see _DIR_DUMP
30 *
31 * @return string
32 */
33function dump_repertoire() {
34        $repertoire = _DIR_DUMP;
35        if (!@file_exists($repertoire)
36                and !$repertoire = sous_repertoire(_DIR_DUMP, '', false, true)
37        ) {
38                $repertoire = preg_replace(',' . _DIR_TMP . ',', '', _DIR_DUMP);
39                $repertoire = sous_repertoire(_DIR_TMP, $repertoire);
40        }
41
42        return $repertoire;
43}
44
45
46/**
47 * Nom du fichier de sauvegarde
48 *
49 * la fourniture de l'extension permet de vérifier que le nom n'existe pas déjà.
50 *
51 * @param string $dir Chemin de stockage du fichier
52 * @param string $extension Extension du fichier de sauvegarde
53 * @return string
54 */
55function dump_nom_fichier($dir, $extension = 'sqlite') {
56        include_spip('inc/texte');
57        $site = 'spip';
58        if (isset($GLOBALS['meta']['nom_site'])) {
59                $site = typo($GLOBALS['meta']['nom_site']); // extraire_multi
60                $site = couper(translitteration(trim($site)), 30, "");
61                $site = preg_replace(array(",\W,is", ",_(?=_),", ",_$,"), array("_", "", ""), $site);
62        }
63
64        $site .= '_' . date('Ymd');
65
66        $nom = $site;
67        $cpt = 0;
68        while (file_exists($dir . $nom . ".$extension")) {
69                $nom = $site . sprintf('_%03d', ++$cpt);
70        }
71
72        return $nom . ".$extension";
73}
74
75/**
76 * Détermine le type de serveur de sauvegarde,
77 * sqlite2 ou sqlite3
78 *
79 * @return string
80 */
81function dump_type_serveur() {
82
83        // chercher si sqlite2 ou 3 est disponible
84        include_spip('req/sqlite3');
85        if (spip_versions_sqlite3()) {
86                return 'sqlite3';
87        }
88
89        include_spip('req/sqlite2');
90        if (spip_versions_sqlite2()) {
91                return 'sqlite2';
92        }
93
94        return '';
95}
96
97/**
98 * Conteneur pour les arguments de la connexion
99 *
100 * Si on passe $args, les arguments de la connexion sont memorisés.
101 * Renvoie toujours les derniers arguments memorisés.
102 *
103 * @staticvar array $connect_args    Pour stocker le premier conteneur
104 * @param array $args
105 * @return array
106 */
107function dump_serveur($args = null) {
108        static $connect_args = null;
109        if ($args) {
110                $connect_args = $args;
111        }
112
113        return $connect_args;
114}
115
116function dump_connect_args($archive) {
117        if (!$type_serveur = dump_type_serveur()) {
118                return null;
119        }
120
121        return array(dirname($archive), '', '', '', basename($archive, ".sqlite"), $type_serveur, 'spip');
122}
123
124/**
125 * Initialiser un dump
126 *
127 * @param string $status_file Fichier contenant les informations serialisees sur le statut de l'export
128 * @param string $archive Nom de l'archive (stockee dans le fichier de statut)
129 * @param array $tables Liste des tables a exporter (autocaculee par defaut)
130 * @param array $where Condition sur l'export
131 * @param string $action Pour differencier la sauvegarde de l'import
132 * @return bool/string
133 */
134function dump_init($status_file, $archive, $tables = null, $where = array(), $action = 'sauvegarde') {
135        $status_file = _DIR_TMP . basename($status_file) . ".txt";
136
137        if (lire_fichier($status_file, $status)
138                and $status = unserialize($status)
139                and $status['etape'] !== 'fini'
140                and filemtime($status_file) >= time() - 120
141        ) // si le fichier status est trop vieux c'est un abandon
142        {
143                return _T("dump:erreur_" . $action . "_deja_en_cours");
144        }
145
146        if (!$type_serveur = dump_type_serveur()) {
147                return _T('dump:erreur_sqlite_indisponible');
148        }
149
150        if (!$tables) {
151                list($tables, ) = base_liste_table_for_dump(lister_tables_noexport());
152        }
153        $status = array('tables' => $tables, 'where' => $where, 'archive' => $archive);
154
155        $status['connect'] = dump_connect_args($archive);
156        dump_serveur($status['connect']);
157        if (!spip_connect('dump')) {
158                return _T('dump:erreur_creation_base_sqlite');
159        }
160
161        // la constante sert a verifier qu'on utilise bien le connect/dump du plugin,
162        // et pas une base externe homonyme
163        if (!defined('_DUMP_SERVEUR_OK')) {
164                return _T('erreur_connect_dump', array('dump' => 'dump'));
165        }
166
167        $status['etape'] = 'init';
168
169        if (!ecrire_fichier($status_file, serialize($status))) {
170                return _T('dump:avis_probleme_ecriture_fichier', array('fichier' => $status_file));
171        }
172
173        return true;
174}
175
176/**
177 * Afficher l'avancement de la copie
178 *
179 * @staticvar int $etape    Nombre de fois ou on est passe dans cette foncion
180 * @param <type> $courant   Flag pour indiquer si c'est la table sur laquelle on travaille actuellement
181 * @param <type> $total     Nombre total de tables
182 * @param <type> $table     Nom de la table
183 */
184function dump_afficher_progres($courant, $total, $table) {
185        static $etape = 1;
186        if (unique($table)) {
187                if ($total < 0 or !is_numeric($total)) {
188                        echo "<br /><strong>" . $etape . '. ' . "</strong>$table ";
189                } else {
190                        echo "<br /><strong>" . $etape . '. ' . "$table</strong> " . ($courant ? " <i>($courant)</i> " : "");
191                }
192                $etape++;
193        }
194        if (is_numeric($total) and $total >= 0) {
195                echo ". ";
196        } else {
197                echo "(" . (-intval($total)) . ")";
198        }
199        flush();
200}
201
202/**
203 * Écrire le js pour relancer la procédure de dump
204 *
205 * @param string $redirect URL de la prochaine etape du dump
206 * @return string           Code HTML de redirection
207 */
208function dump_relance($redirect) {
209        // si Javascript est dispo, anticiper le Time-out
210        return "<script language=\"JavaScript\" type=\"text/javascript\">window.setTimeout('location.href=\"$redirect\";',300);</script>\n";
211}
212
213
214/**
215 * Marquer la procédure de dump comme finie
216 *
217 * @param string $status_file
218 *     Fichier qui mémorise les infos utiles concernant la sauvegarde en cours
219 * @param string $action
220 *     Type d'action supplémentaire à réaliser :
221 *
222 *     - restaurer : supprimer la structure qui était stockée dans le dump
223 *     - 'auvegarder : stocker dans le dump la structure de la base source
224 */
225function dump_end($status_file, $action = '') {
226        $status_file = _DIR_TMP . basename($status_file) . ".txt";
227        if (!lire_fichier($status_file, $status)
228                or !$status = unserialize($status)
229        ) {
230                return;
231        }
232
233        switch ($action) {
234                case 'restaurer':
235                        // supprimer la structure qui etait stockee dans le dump
236                        sql_delete('spip_meta', "nom='dump_structure_temp'");
237                        break;
238                case 'sauvegarder':
239                        // stocker dans le dump la structure de la base source
240                        $structure = array();
241                        foreach ($status['tables_copiees'] as $t => $n) {
242                                $structure[$t] = sql_showtable($t, true);
243                        }
244                        dump_serveur($status['connect']);
245                        spip_connect('dump');
246                        // si spip_meta n'a pas ete backup elle n'est pas dans le dump, il faut la creer pour y stocker cette meta
247                        if (!sql_showtable("spip_meta", true, "dump")) {
248                                $desc = sql_showtable("spip_meta", true);
249                                sql_create("spip_meta", $desc['field'], $desc['key'], false, false, "dump");
250                        }
251                        sql_delete('spip_meta', "nom='dump_structure_temp'", 'dump'); #enlever une vieille structure deja la, au cas ou
252                        sql_insertq('spip_meta',
253                                array('nom' => 'dump_structure_temp', 'valeur' => serialize($structure), 'impt' => 'non'), array(), 'dump');
254                        break;
255        }
256
257        $status['etape'] = 'fini';
258        ecrire_fichier($status_file, serialize($status));
259}
260
261/**
262 * Lister les fichiers de sauvegarde existant dans un repertoire
263 * trie par nom, date ou taille
264 *
265 * @param string $dir Repertoire de sauvegarde
266 * @param string $tri Tri pour recuperer les fichiers
267 * @param string $extension Extension des fichiers de sauvegarde
268 * @param int $limit Nombre max de fichiers listes
269 * @return array
270 */
271function dump_lister_sauvegardes($dir, $tri = 'nom', $extension = "sqlite", $limit = 100) {
272        $liste_dump = preg_files($dir, '\.' . $extension . '$', $limit, false);
273
274        $n = strlen($dir);
275        $tn = $tl = $tt = $td = array();
276        foreach ($liste_dump as $fichier) {
277                $d = filemtime($fichier);
278                $t = filesize($fichier);
279                $fichier = substr($fichier, $n);
280                $tl[] = array('fichier' => $fichier, 'taille' => $t, 'date' => $d);
281                $td[] = $d;
282                $tt[] = $t;
283                $tn[] = $fichier;
284        }
285        if ($tri == 'taille') {
286                array_multisort($tt, SORT_ASC, $tl);
287        } elseif ($tri == 'date') {
288                array_multisort($td, SORT_ASC, $tl);
289        } else {
290                array_multisort($tn, SORT_ASC, $tl);
291        }
292
293        return $tl;
294}
295
296/**
297 * Extraire le statut contenu dans un fichier
298 *
299 * @param $status_file       Nom du fichier stocke dans _DIR_TMP
300 * @return array
301 */
302function dump_lire_status($status_file) {
303        $status_file = _DIR_TMP . basename($status_file) . ".txt";
304        if (!lire_fichier($status_file, $status)
305                or !$status = unserialize($status)
306        ) {
307                return '';
308        }
309
310        return $status;
311}
312
313/**
314 * Verifier qu'un sauvegarde est finie
315 *
316 * @param $status_file      Nom du fichier stocke dans _DIR_TMP
317 * @return string           Chaine non vide s'il reste des choses a faire
318 */
319function dump_verifie_sauvegarde_finie($status_file) {
320        if (!$status = dump_lire_status($status_file)
321                or $status['etape'] !== 'fini'
322        ) {
323                return '';
324        }
325
326        return ' ';
327}
328
329/**
330 * Recuperer le nom du fichier d'archivage qui est memorise dans le fichier de statut
331 *
332 * @param $status_file      Nom du fichier stocke dans _DIR_TMP
333 * @return string           Nom ou chaine vide si on a un probleme
334 */
335function dump_nom_sauvegarde($status_file) {
336        if (!$status = dump_lire_status($status_file)
337                or !file_exists($f = $status['archive'] . ".sqlite")
338        ) {
339                return '';
340        }
341
342        return $f;
343}
344
345/**
346 * Recuperer la taille du fichier de sauvegarde
347 *
348 * @param $status_file      Nom du fichier stocke dans _DIR_TMP
349 * @return string/int       Taille ou Chaine vide en cas de probleme
350 */
351function dump_taille_sauvegarde($status_file) {
352        if (!$f = dump_nom_sauvegarde($status_file)
353                or !$s = filesize($f)
354        ) {
355                return '';
356        }
357
358        return $s;
359}
360
361/**
362 * Recuperer la date de derniere modification du fichier de sauvegarde
363 *
364 * @param $status_file      Nom du fichier stocke dans _DIR_TMP
365 * @return string/int       Date ou Chaine vide en cas de probleme
366 */
367function dump_date_sauvegarde($status_file) {
368        if (!$f = dump_nom_sauvegarde($status_file)
369                or !$d = filemtime($f)
370        ) {
371                return '';
372        }
373
374        return date('Y-m-d', $d);
375}
Note: See TracBrowser for help on using the repository browser.