source: spip-zone/_outils_/smart_paquets/inc_empaqueteur.php @ 69163

Last change on this file since 69163 was 69163, checked in by cedric@…, 7 years ago

cas sans comit et cas du fichier avec /

File size: 22.5 KB
Line 
1<?php
2
3// -------------------------------------- APPEL PRINCIPAL ------------------------------------------
4
5// Fonction principale appelee par le script empaqueteur.php
6// Elle lance successivement:
7// 1. la creation des zips et de la base des logos
8// 2. le nettoyage des paquets obsoletes
9// 3. la creation du fichier xml des paquets
10// 4. la creation du fichier des traductions de Salvatore
11// 5. la creation d'un index des logos
12//
13// $url                 : url du repository des sources (ex: svn://zone.spip.org/spip-zone)
14// $dir_repo    : repertoire racine des sources extraits du repository (ex: spip-zone)
15// $dir_paq             : repertoire de depot des paquets crees (ex: paquets)
16// $src                 : nom du fichier listant les archives a creer (ex: archivelist.txt)
17// $dest                : nom sans extension du fichier xml recapitulant toutes les archives (ex: archives)
18// $dtd_prio    : DTD a utiliser en priorite (plugin ou paquet)
19// $nom_vcs             : gestionnaire de versions motorisant le repository concerne (ex: svn)
20// $mail_to             : destinataire des mails d'information
21// $mail_from   : emetteur des mails d'information
22//
23// return               : aucun
24function empaqueteur($url, $dir_repo, $dir_paq, $src, $dest, $dtd_prio, $nom_vcs, $mail_to, $mail_from) {
25        global $erreurs;
26        $dir_tmp = $dir_paq.'tmp/';
27        require('inc_outils.php');
28
29        // On charge les includes correspondant aux DTD utilisees
30        require('empaqueteur_plugin.php');
31        require('empaqueteur_paquet.php');
32
33        $erreurs = array();
34        $url = trim($url);
35        $dir_repo = rtrim($dir_repo ? $dir_repo : basename($url),'/') .'/';
36        $dir_paq = rtrim($dir_paq ? $dir_paq : '.','/') .'/';
37       
38        // 1. creation des zips et de la base des logos
39        list($depot, $zips, $logos, $xmls) = empaqueteur_archives($url, $dir_repo, $dir_paq, $src, $nom_vcs, $dtd_prio);
40       
41        // 2. nettoyage des paquets et logos obsoletes
42        if (!$erreurs) {
43                $fichiers_a_conserver = array_keys($zips);
44                $fichiers_a_conserver = array_merge($fichiers_a_conserver, $logos);
45                $fichiers_a_conserver = array_merge($fichiers_a_conserver, $xmls);
46                // ne pas nettoyer le fichier archives.xml !
47                foreach(is_array($dest) ? $dest : array($dest) as $nom_dest)
48                        $fichiers_a_conserver[] = $nom_dest . '.xml';
49                // ne pas nettoyer le fichier traductions.txt !
50                $fichiers_a_conserver[] = 'traductions.txt';
51                // ne pas nettoyer l'index des logos logos.php !
52                $fichiers_a_conserver[] = 'logos.php';
53                nettoyer_vieux_fichiers($fichiers_a_conserver, $dir_paq . $dir_repo, $dir_tmp);
54        }
55        elseif ($mail_to) 
56                envoyer_mail($erreurs, $mail_to, $mail_from);
57
58       
59        // 3. la creation du fichier xml des paquets
60        // -- obtention des contenus du fichier xml des paquets et de celui des traductions Salvatore
61        list($archives, $salvatore) = empaqueteur_resultats($depot, $zips);
62        if ($archives)
63                empaqueteur_xml_archives($dest . '.xml', $archives, $dir_paq, $dir_repo);
64        else
65                echo_trace("Aucun Zip produit");
66
67        // 4. la creation du fichier des traductions de Salvatore
68        if ($salvatore)
69                empaqueteur_salvatore('traductions.txt', $salvatore, $dir_paq, $dir_repo);
70        else
71                echo_trace("Aucune traduction avec Salvatore");
72
73        // 5. la creation d'un index des logos
74        empaqueteur_index_logos('logos.php', $dir_paq, $dir_repo);
75}
76
77
78// ---------------------------------- CREATION DES ARCHIVES ----------------------------------------
79
80// Fonction de creation des zips et de la base des logos
81// Elle lance successivement:
82// 1. Creation des repertoires de travail et import initial (uniquement la premiere fois)
83// 2. Check-out ou update des sources a archiver
84// 3. Lecture de la liste des archives a creer
85// 4. Creation de la liste des archives requises
86//
87// $url                 : url du repository des sources (ex: svn://zone.spip.org/spip-zone)
88// $dir_repo    : repertoire racine des sources extraits du repository (ex: spip-zone)
89// $dir_paq             : repertoire de depot des paquets crees (ex: paquets)
90// $src                 : nom du fichier listant les archives a creer (ex: archivelist.txt)
91// $nom_vcs             : gestionnaire de versions motorisant le repository concerne (ex: svn)
92// $dtd_prio    : DTD a utiliser en priorite (plugin ou paquet)
93//
94// return               : tableau des infos du depot et des zips crees
95//                                      0 : tableau associatif (info -> valeur) de chaque info collectee sur le depot
96//                                      1 : tableau associatif (nom de l'archive -> liste des infos) des zips crees
97//                                      2 : tableau de logos crees
98//                                      3 : tableau des xml copies
99function empaqueteur_archives($url, $dir_repo, $dir_paq, $src, $nom_vcs, $dtd_prio) {
100        // Definition des deux sous-repertoires temporaires et definitifs des paquets
101        $dir_tmp = $dir_paq.'tmp/';
102        $dir_paq .= $dir_repo;
103        $dirs_changed = null;
104
105        // Test pour savoir si le gestionnaire de version est bien installe sur le serveur
106        if (!function_exists($vcs = 'vcs_exec_' . $nom_vcs)) {
107                echo_trace("VCS non disponible: '$nom_vcs'");
108                $vcs = 'explode'; // i.e. ne fait rien de ses arguments.
109        }
110
111        // 1. Creation des repertoires de travail et import initial
112        if (!file_exists($dir_repo)){
113                preparer_chemin(dirname(rtrim($dir_repo,'/')));
114                if ($url) $vcs("checkout", "$url $dir_repo");
115        }
116        if (!file_exists($dir_paq))
117                preparer_chemin($dir_paq);
118        if (!file_exists($dir_tmp))
119                preparer_chemin($dir_tmp);
120
121        // 2. Check-out ou update des sources a archiver
122        // Si le repo est en file:// on fait un svnsync dessus,
123        // le up est fait par un hook post-commit sur ce qui a change uniquement
124        // sauf une fois par jour
125        if (preg_match(',^file://,',$url)) {
126                // supprimer le fichier qui trace les dossiers modifies avant sync ou up
127                unlink($fc = rtrim($dir_repo,'/')."/dirs-changed.txt");
128                $vcs("sync", $url);
129                if (_FORCE_UPDATE){
130                        $vcs("up",rtrim($dir_repo,'/'));
131                }
132                else {
133                        $dirs_changed = (file_exists($fc)?file($fc):array());
134                        $dirs_changed = array_map("trim",$dirs_changed);
135                        $dirs_changed = array_map("dirname",$dirs_changed);
136                        $dirs_changed = array_unique($dirs_changed);
137                        $dirs_changed = array_filter($dirs_changed);
138                        $d = rtrim($dir_repo,'/')."/";
139                        foreach($dirs_changed as $k=>$v){
140                                $dirs_changed[$k] = $d . ($v=="."?"":$v);
141                        }
142                        echo_trace("Dossiers modifies : ".implode(", ",$dirs_changed));
143                }
144        }
145        elseif ($url) {
146                // le up est fait si archivelistmodifie sinon une fois par jour
147                if (_FORCE_UPDATE)
148                        $vcs("up", rtrim($dir_repo,'/'));
149        }
150
151        // 3. Lecture de la liste des archives a creer et des informations sur le depot
152        list($depot, $paquets) = lister_paquets($dir_repo . $src);
153
154        // 4. Creation de la liste des archives requises
155        $zips = $logos = $xmls = array();
156        foreach($paquets as $_paquet){
157                if ($_paquet['revision']=='HEAD' 
158                AND list($infos, $logo, $xml) = creer_paquet($_paquet, $dir_repo, $dir_paq, $dir_tmp, $vcs, $dtd_prio, $dirs_changed)) {
159                        $zips[$_paquet['nom'] .".zip"] = $infos;
160                        if ($logo) $logos[] = $logo;
161                        if ($xml) $xmls[] = $xml;
162                        if (intval(_SLEEP_BETWEEN)) usleep(_SLEEP_BETWEEN);
163                }
164        }
165        echo_trace(count($zips) . " trouves");
166
167        return array($depot, $zips, $logos, $xmls);
168}
169
170
171// Lister les paquets demandes dans le fichier des archives
172// et compiler les informations sur le depot
173//
174// $src                 : nom du fichier listant les archives a creer
175//
176// return               : tableau des infos du depot et des archives a creer
177//                                      0 : tableau associatif (info -> valeur) de chaque info collectee sur le depot
178//                                      1 : tableau associatif des archives a creer (source, nom, nom_dossier et revision)
179function lister_paquets($src) {
180
181        echo_trace("chargement de $src");
182        if (!$archivefile=file($src)){
183                echo_trace("Erreur : Impossible de lire $src");
184                return array();
185        }
186
187        $depot = array();
188        $paquets = array();
189        foreach($archivefile as $ligne=>$lignepaquet){
190                //on vire le retour ligne de la fin
191                $lignepaquet=rtrim($lignepaquet);
192                if (strlen($lignepaquet)) {
193                        if (substr($lignepaquet,0,1)!="#") {
194                                // C'est une ligne de definition d'un paquet :
195                                // - on separe les parametres
196                                // - et on fixe ceux manquants
197                                $a = explode(";",$lignepaquet);
198                                $b = preg_split("/:/",$a[0]);
199                                $source = trim($b[0]);
200                                $svn_version = empty($b[1]) ?'HEAD' : trim($b[1]);             
201                                $nom_paquet = empty($a[1]) ? basename($source) : trim($a[1]);
202                                $nom_dossier = empty($a[2]) ? $nom_paquet : trim($a[2]);
203                                // Ajout au tableau des paquets a construire
204                                $paquets[] = array('source'=>rtrim($source,'/'),
205                                                   'nom'=>$nom_paquet,
206                                                   'nom_dossier'=>$nom_dossier,
207                                                   'revision'=>$svn_version);
208                        }
209                        else if (preg_match('#@([^=\s]+)\s*=(.+)$#', substr($lignepaquet, 1), $matches)){
210                                // C'est une ligne d'information sur le depot
211                                // - on stocke le parametre trouve
212                                $depot[trim($matches[1])] = trim($matches[2]);
213                        }
214                }
215        }
216
217        echo_trace(count($depot)." informations de depot definies");
218        echo_trace(count($paquets)." paquets definis");
219        return array($depot, $paquets);
220}
221       
222
223// Fonction de creation d'un paquet soit :
224// - de l'archive des sources (zip actuellement)
225// - des informations completes sur le paquet (yc la liste des traductions)
226// - et de son logo eventuel
227//
228// $paquet              : tableau des infos sur l'archive a creer
229// $dir_repo    : repertoire racine des sources extraits du repository
230// $dir_paq             : repertoire de depot des paquets crees
231// $dir_tmp             : repertoire temporaire de depot des archives crees
232// $vcs                 : fonction d'interface du vcs utilise (ex: vcs_exec_svn)
233// $dtd_prio    : DTD a utiliser en priorite (plugin ou paquet)
234// $dirs_changed : repertoires modifies depuis le dernier passafe
235//
236// return               : tableau des infos
237//                  0 : paquet cree
238//                                              0 : taille du paquet
239//                                              1 : date du paquet
240//                                              2 : arborescence des sources du paquet (relatif a l'url des sources)
241//                                              3 : date du dernier commit
242//                                              4 : liste des traductions sous la forme de la balise XML <traductions>
243//                                              5 : contenu du fichier xml du plugin
244//                                              6 : balises nom, slogan et description en multi tirees des fichiers de langue
245//                                              7 : dtd utilisee
246//                  1 : logo cree (fichier)
247//                  2 : xml recopie (fichier)
248function creer_paquet($paquet, $dir_repo, $dir_paq, $dir_tmp, $vcs, $dtd_prio, $dirs_changed=null) {
249        // Verifier le repertoire source du paquet a creer
250        $dsource = $dir_repo. $paquet['source'];
251        if (!file_exists($dsource)){
252                echo_trace("Erreur : $dsource inexistant");
253                return false;
254        }
255
256        $cache = $dir_paq . ".".str_replace("/",".",$paquet['nom']).".cache";
257        $zip = $paquet['nom'] .".zip";
258        $zippath = $dir_paq.$zip;
259
260        if (!is_null($dirs_changed)
261                AND !in_array($dsource,$dirs_changed)
262                AND file_exists($zippath)
263                AND file_exists($cache)
264                AND $res = file_get_contents($cache)
265                AND $res = unserialize($res)
266        ) {
267
268                // rien a faire
269                echo_trace("(info) $zippath depuis le cache $cache");
270        }
271        else {
272
273                // Creation de l'archive
274                // -- Ajouter le fichier svn.revision dans les fichiers de l'archive pour les besoins de SPIP
275                $rev = $dsource . "/svn.revision";
276                $vcs("info", "$dsource > $rev");
277                $info = renseigner_revision_paquet($rev);
278                $date_commit = $info[1];
279                // -- zipper les sources incluant le fichier svn.revision
280                if (!archiver($dsource, $zip, $zippath, $paquet['nom_dossier'], $info, $dir_tmp))
281                        return false;
282                // -- Traiter le cas de SPIP :
283                //    copier le svn.revision de stable/spip.zip qui permet de connaitre la derniere version stable
284                if ($zip=="stable/spip.zip") {
285                        // necessaire de remettre le fichier a la date actuelle
286                        // car il a la date du dernier commit sur ce paquet
287                        # touch($dsource."/svn.revision");
288                        copie_update($rev, $dir_paq.dirname($zip)."/svn.revision");
289                }
290                // -- supprimer le fichier info revision cree ci-dessus
291                @unlink($rev);
292
293                // Determination de la dtd a utiliser
294                $dtd = '';
295                $f = $dsource . '/' . $dtd_prio . '.xml';
296                if (file_exists($f))
297                        $dtd = $dtd_prio;
298                else {
299                        $autre_dtd = ($dtd_prio == 'plugin') ? 'paquet' : 'plugin';
300                        $f = $dsource . '/' . $autre_dtd . '.xml';
301                        if (file_exists($f))
302                                $dtd = $autre_dtd;
303                        else {
304                                // Paquet sans xml correspondant a une contribution quelconque
305                                echo_trace("(info) Paquet $zip sans fichier XML");
306                                $desc = '';
307                        }
308                }
309
310                $traductions = '';
311                $logo = '';
312                $multis = '';
313                $xml = false;
314                if ($dtd) {
315                        // Recuperer le xml qui decrit le plugin et suppression de l'entete XML si elle existe
316                        $re = ",<"."\?xml[^>]*\?".">,Uims";
317                        $desc = trim(preg_replace($re, '', file_get_contents($f)));
318
319                        // Construire la liste des traductions du plugin
320                        $traductions = compiler_traductions($dsource);
321
322                        // Contruire les balises multi du nom, slogan et description qui ne sont plus dans le paquet
323                        $f = 'empaqueteur_' . $dtd . '_multi';
324                        $multis = !function_exists($f) ? '' : $f($dsource);
325
326                        // Creer le logo du paquet
327                        $f = 'empaqueteur_' . $dtd . '_logo';
328                        $f = !function_exists($f) ? '' : $f($desc, $dsource);
329                        if ($f AND file_exists($f) AND preg_match('/[.][^.]*$/', $f, $r)) {
330                                $logo = $paquet['nom'] . $r[0];
331                                $d = $dir_paq . $logo;
332                                copy($f, $d);
333                        }
334
335                        // Copier le fichier xml de description du plugin au meme endroit que les logos et zips
336                        $xml = $paquet['nom'] . '.xml';
337                        if (strlen($desc))
338                                file_put_contents($dir_paq . $xml, $desc);
339                }
340
341                $res = array(
342                                        array(
343                                                filesize($zippath),
344                                                filemtime($zippath),
345                                                $paquet['source'],
346                                                $date_commit,
347                                                $traductions,
348                                                $desc,
349                                                $multis,
350                                                $dtd),
351                                        $logo,
352                                        $xml);
353
354                file_put_contents($cache,serialize($res));
355        }
356       
357        return $res;
358}
359
360
361// Fonction de creation d'une archive des sources contenu dans une arborescence donnee.
362// Aujourd'hui l'archive est toujours un zip
363//
364// $source              : emplacement des sources a archiver
365// $zip                 : nom de l'archive a creer
366// $zippath             : chemin complet de l'archive a creer
367// $nom_dossier : arborescence dans le zip qui sera cree lors du dezippage
368// $rev                 : tableau des informations sur le dernier commit (revision, date)
369// $dir_tmp             : repertoire temporaire de depot des archives creees
370//
371// return               : true/false
372function archiver($source, $zip, $zippath, $nom_dossier, $rev, $dir_tmp){
373        $zipfile = basename($zip);
374        list($revision, $date_commit) = $rev;
375        $date_paquet = file_exists($zippath) ? filemtime($zippath) : 0;
376        // tester si le paquet est a jour
377        if (strtotime($date_commit) <= $date_paquet AND !_FORCE_UPDATE) {
378                echo_trace("$zip OK : du ".date('Y-m-d H:i:s',$date_paquet)." / dernier commit du $date_commit");
379                return true;
380        }
381        else {
382                echo_trace("$zip OLD : du ".date('Y-m-d H:i:s',$date_paquet)." / dernier commit du $date_commit");
383                $tmp = $dir_tmp.$nom_dossier;
384                preparer_chemin($tmp);
385                if (!rename($source,$tmp)) {
386                        echo_trace("Erreur : $source --> $tmp");
387                        return false;
388                } else {
389                        $d = getcwd();
390                        chdir($dir_tmp);
391                        $base_dir = reset(explode('/',$nom_dossier));
392                        // zipper en prenant la date du fichier le plus recent
393                        // comme date du paquet
394                        exec_trace("zip -roq $zipfile $base_dir -x \*/.svn\*");
395                        chdir($d);
396
397                        $date_paquet = filemtime($dir_tmp.$zipfile);
398                        // cas ou le dernier commit consiste en la suppression de fichiers
399                        // du coup le zip est plus ancien que le dernier commit
400                        // on corrige manuellement
401                        if ($date_paquet<strtotime($date_commit)) {
402                                touch($dir_tmp.$zipfile,strtotime($date_commit)+1);
403                        }
404                        rename($tmp,$source);
405                }
406                supprimer_chemin($dir_tmp,$nom_dossier);
407                copie_update($dir_tmp.$zipfile,$zippath);
408                return true;
409        }
410}
411
412
413// Fonction de compilation de la liste des traductions d'un plugin sous forme d'une suite
414// de balises <traduction>
415// On considere que les fichiers de langue ou les rapports de salvatore sont toujours dans
416// le sous-repertoire lang/
417//
418// $source              : emplacement des sources du plugin
419//
420// return               : chaine composee des balises <traduction>
421function compiler_traductions($source){
422
423        // On charge une fois la liste des codes de langues
424        if (empty($GLOBALS['codes_langues']));
425                include('inc_langues.php');
426
427        $traductions = '';
428
429        // Determination des modules sous salvatore : on cherche les rapports xml
430        $modules_salvatore = array();
431        if ($rapports = glob($source . '/lang/*.xml')) {
432                foreach ($rapports as $_rapport) {
433                        $modules_salvatore[] = basename($_rapport, '.xml');
434                        $contenu = file_get_contents($_rapport);
435                        $traductions .= $contenu;
436                }
437        }
438
439        // Determination des modules non traduits par salvatore
440        // Cette recherche n'est pas totalement deterministe car on est oblige de considerer
441        // qu'il existe toujours un fichier module_fr.php pour identifier le nom du module
442        if ($fichiers_fr = glob($source . '/lang/*_fr.php')) {
443                foreach ($fichiers_fr as $_fichier_fr) {
444                        $nom_fichier = basename($_fichier_fr, '.php');
445                        // On exclut les fichiers de traduction du paquet.xml
446                        if (strpos($nom_fichier, 'paquet-') === false ) {
447                                $module = substr($nom_fichier, 0, strlen($nom_fichier)-3);
448                                // Si ce module n'a pas ete traite dans un rapport Salvatore on cherche toutes
449                                // ses traductions via les fichiers de langue.
450                                if (isset($module) && !in_array($module, $modules_salvatore) 
451                                AND ($fichiers_langue = glob($source . "/lang/".$module."_*.php"))) {
452                                        $liste_langues = '';
453                                        foreach ($fichiers_langue as $_fichier_langue) {
454                                                $nom_fichier = basename($_fichier_langue, '.php');
455                                                $langue = substr($nom_fichier, strlen($module) + 1 - strlen($nom_fichier));
456                                                // Si la langue est reconnue, on l'ajoute a la liste des traductions
457                                                // Comme on ne connait pas les traducteurs, la balise est donc vide
458                                                if (isset($GLOBALS['codes_langues'][$langue]) AND $langue != 'fr')
459                                                        $liste_langues .= "\t" . '<langue code="' . $langue . '" />' . "\n";
460                                        }
461                                        // Le gestionnaire n'est pas precise et la langue de reference est toujours le fr
462                                        $traductions .= '<traduction module="' . $module . '" reference="fr">' . "\n" . 
463                                                                        $liste_langues .
464                                                                        '</traduction>' . "\n";                 
465                                }
466                        }
467                }
468        }
469       
470        // On inclus les balise <traduction> dans une balise <traductions> sans attribut qui
471        // facilite le travail du parser
472        if ($traductions)
473                $traductions = '<traductions>' . "\n" . $traductions . '</traductions>' . "\n"; 
474       
475        return $traductions;
476}
477
478
479// --------------------------- CREATION DES FICHIERS RESULTAT --------------------------------------
480
481// Construit la concatenation des informations essentielles
482// contenu dans les fichiers plugin.xml et des informations relatives a chaque paquet
483// Construit egalement les informations de traduction par salvatore a destination du fichier traductions.txt
484function empaqueteur_resultats($depot, $zips) {
485        $xml = '';
486        $salvatore = '';
487        foreach($zips as $zip => $infos) {
488                list($size, $time, $source, $commit, $traductions, $descr_xml, $multis, $dtd) = $infos;
489                $f = 'empaqueteur_' . $dtd . '_xml';
490                // Bloc d'info du paquet
491                $xml .= "<archive id=\"$zip\"" . ($dtd ? " dtd=\"$dtd\"" : "") . ">
492<zip>
493        <file>$zip</file>
494        <size>$size</size>
495        <date>$time</date>
496        <source>$source</source>
497        <last_commit>$commit</last_commit>
498</zip>
499$traductions
500$descr_xml
501$multis
502\n</archive>\n\n";
503                // Bloc d'info pour Salvatore si il existe
504                if (preg_match_all("#<salvatore\s+module=['\"](\w*)['\"]\s+reference=['\"](\w*)['\"]\s*/>#i", $descr_xml, $matches)) {
505                        foreach ($matches[1] as $_i => $_module) {
506                                $salvatore .= rtrim($depot['url_serveur'], '/') . '/' . rtrim($source, '/') . '/lang/;' . 
507                                                          $_module . ';' .
508                                                          $matches[2][$_i] . "\n";
509                        }
510                }
511        }
512
513        // On complete les archives avec les informations du depot
514        // Pour l'instant ce bloc n'implemente pas la nouvelle DTD
515        if (!$xml) return '';
516        $xml_depot = '';
517        foreach ($depot as $_balise => $_valeur) {
518                $xml_depot .= "<$_balise>$_valeur</$_balise>\n";
519        }
520        if ($xml_depot) 
521                $xml_depot = "<depot>\n$xml_depot</depot>\n";
522        $xml = "$xml_depot
523<archives>
524$xml
525</archives>";
526
527        if($salvatore){
528        // On ajoute une en-tete au fichier genere
529        $salvatore = 
530"# LISTE DES PLUGINS / SQUELETTES UTILISANT SALVATORE
531# --------------------------------------------------
532# Depot : " . $depot['titre'] . "
533# Generation par Smart-Paquets le " . date('d-m-Y H:i') . "
534#\n" . $salvatore;
535        }
536        return array($xml, $salvatore);
537}
538
539// Fonction creant le fichier xml recapitulant toutes les archives creees
540// et le fichier representant son sha
541//
542// Ne pas le reecrire si rien de neuf, c'est + efficace et ca permet
543// au detecteur de nouvelle version d'utiliser If-Modified-Since.
544//
545// Attention, file_put_contents fait ce qu'il veut de certaines lignes vides
546// http://fr2.php.net/manual/fr/function.file-put-contents.php
547//
548// $nom_fichier : nom du fichier xml recapitulant toutes les archives
549// $archives    : contenu du nouveau fichier xml resultant des archives creees
550// $dir_paq             : repertoire de depot des paquets crees
551// $dir_repo    : repertoire racine des sources extraits du repository
552//
553// return               : aucun
554function empaqueteur_xml_archives($nom_fichier, $archives, $dir_paq, $dir_repo)
555{
556        $taille = strlen($archives);
557        $f = $dir_paq . $dir_repo . $nom_fichier;
558        $old = (file_exists($f)) ? trim(file_get_contents($f)) : '';
559        if ($old != $archives) {
560                echo_trace("Nouveau $f de taille $taille");
561                file_put_contents($f, $archives);
562               
563                // On cree le fichier contenant le sha1 du fichier xml
564                $sha = $dir_paq . $dir_repo . basename($nom_fichier, '.xml') . '.sha';
565                file_put_contents($sha, sha1_file($f));
566               
567                return;
568        }
569        echo_trace("$f intact (taille: $taille)");
570}
571
572
573// Fonction creant le fichier des traductions de Salvatore
574//
575// Ne pas le reecrire si rien de neuf, c'est + efficace et ca permet
576// au detecteur de nouvelle version d'utiliser If-Modified-Since.
577//
578// Attention, file_put_contents fait ce qu'il veut de certaines lignes vides
579// http://fr2.php.net/manual/fr/function.file-put-contents.php
580//
581// $nom_fichier : nom du fichier des traductions
582// $salvatore   : contenu du nouveau fichier des traductions Salvatore
583// $dir_paq             : repertoire de depot des paquets crees
584// $dir_repo    : repertoire racine des sources extraits du repository
585//
586// return               : aucun
587function empaqueteur_salvatore($nom_fichier, $salvatore, $dir_paq, $dir_repo)
588{
589        $taille = strlen($salvatore);
590        $fichier = $dir_paq . $dir_repo . $nom_fichier;
591        $old = (file_exists($fichier)) ? trim(file_get_contents($fichier)) : '';
592        if ($old != $salvatore) {
593                echo_trace("Nouveau $fichier de taille $taille");
594                file_put_contents($fichier, $salvatore);
595                return;
596        }
597        echo_trace("$fichier intact (taille: $taille)");
598}
599
600
601// Fonction creant le fichier index des logos permettant d'afficher une page
602// de controle des logos
603//
604// Le fichier est recree systematiquement
605//
606// $nom_fichier : nom du fichier index des logos
607// $dir_paq             : repertoire de depot des paquets crees
608// $dir_repo    : repertoire racine des sources extraits du repository
609//
610// return               : aucun
611function empaqueteur_index_logos($nom_fichier, $dir_paq, $dir_repo)
612{
613        $contenu = '';
614        $logos = array_merge(glob($dir_paq . $dir_repo . '*.png'),
615                                                glob($dir_paq . $dir_repo . '*.gif'),
616                                                glob($dir_paq . $dir_repo . '*.jpg'));
617        foreach($logos as $_logo)
618                $contenu .= '<img src="' . basename($_logo) . '" />' . "\n";
619
620        $fichier = $dir_paq . $dir_repo . $nom_fichier;
621        if(strlen($contenu)){
622                file_put_contents($fichier, $contenu);
623                echo_trace("Nouvel index cree : " . count($logos) . " logos");
624        }else{
625                echo_trace("Aucun logo trouvés, pas d'index créé");
626        }
627}
628
629?>
Note: See TracBrowser for help on using the repository browser.